Attachment #425987 for bug #223570

View Details Raw Unified Return to Bug 223570

| Differences between



2021-04-12  Cathie Chen  <cathiechen@igalia.com>

        [CSS contain] Support contain:size
        https://bugs.webkit.org/show_bug.cgi?id=223570

        Reviewed by NOBODY (OOPS!).

        This patch brings initial support of CSS contain:size according to [1],
        It adds shouldApplySizeContainment to indicate whether it is a size containment box.
        The intrinsic sizes of size containment box are determined as if it had no content.
        So cooperating with the layout steps:
          - Calculate logical width: Size containment boxes skip handling children while computing minLogicalWidth
          and maxLogicalWidth in computeIntrinsicLogicalWidths.
          - Layout children.
          - Calculate logical height: At the beginning, size containment boxes reset logical height to the empty content height
          if it is not renderGrid.
        We also need to calculate the sizes according to the layout algorithms.
        - Grid layout:
          To calculate the minLogicalWidth and maxLogicalWidth for indefinite size RenderGrid.
          The widths are calculated by GridTrackSizingAlgorithm: m_minContentSize and m_maxContentSize which are the sum of
          m_baseSize/m_growthLimit of all GridTracks. The size containment RenderGrid skips handling content in resolveIntrinsicTrackSizes
          and the m_maxContentSize will be the sum of m_baseSize. The logical height is same to width, but after calculating
          RenderGrid's logical height, it needs to calculate the track sizes again, to make sure that they are distributed properly.
          We use computeTrackSizesForDefiniteSize(ForRows, trackBasedLogicalHeight) to recalculate it.
        - MultiColumn layout:
          According to the specification, size containment boxes should be monolithic, so we need to extend column height
          for overflow and positioned size containment box. m_spaceShortageForSizeContainment is added to indicate the shortage space
          that need to balance the column heights. adjustSizeContainmentChildForPagination will calculate the shortage.

        [1] https://www.w3.org/TR/css-contain-1/#containment-size

        * rendering/GridTrackSizingAlgorithm.cpp: Add isComputingSizeContainment to indicate if it is calculating sizes
          for indefinite size RenderGrid which size containment.
        (WebCore::GridTrackSizingAlgorithm::computeGridContainerIntrinsicSizes):
          It might skip resolveIntrinsicTrackSizes if isComputingSizeContainment, so growthLimit might be undefined,
          if so, use track.baseSize() instead.
        (WebCore::GridTrackSizingAlgorithm::resolveIntrinsicTrackSizes): Skip resolve the content if isComputingSizeContainment.
        (WebCore::GridTrackSizingAlgorithm::advanceNextState):
        (WebCore::GridTrackSizingAlgorithm::run): Do not stretch the track sizes if isComputingSizeContainment.
        * rendering/GridTrackSizingAlgorithm.h:
        * rendering/RenderBlock.cpp:
        (WebCore::RenderBlock::layoutPositionedObject): Calculate m_spaceShortageForSizeContainment for position size containment
        in adjustSizeContainmentChildForPagination.
        (WebCore::RenderBlock::computeIntrinsicLogicalWidths const): Skip computeBlockPreferredLogicalWidths if shouldApplySizeContainment.
        * rendering/RenderBlockFlow.cpp:
        (WebCore::RenderBlockFlow::computeIntrinsicLogicalWidths const): Skip handling the children for size containment box.
        (WebCore::RenderBlockFlow::adjustBlockChildForPagination): Calculate m_spaceShortageForSizeContainment for child.
        (WebCore::RenderBlockFlow::adjustSizeContainmentChildForPagination): m_spaceShortageForSizeContainment = childOverflowHeight - remainingLogicalHeight.
        * rendering/RenderBlockFlow.h:
        * rendering/RenderBox.cpp:
        (WebCore::RenderBox::updateLogicalHeight): Reset the logical height to empty content height for size containment box.
        (WebCore::RenderBox::isUnsplittableForPagination const): Size containment box is unsplittable.
        * rendering/RenderDeprecatedFlexibleBox.cpp:
        (WebCore::RenderDeprecatedFlexibleBox::computeIntrinsicLogicalWidths const): Ditto.
        * rendering/RenderFileUploadControl.cpp:
        (WebCore::RenderFileUploadControl::computeIntrinsicLogicalWidths const): Ditto.
        * rendering/RenderFlexibleBox.cpp:
        (WebCore::RenderFlexibleBox::computeIntrinsicLogicalWidths const): Ditto.
        * rendering/RenderFragmentedFlow.h:
        * rendering/RenderGrid.cpp:
        (WebCore::RenderGrid::layoutBlock): If it is size containment with infiniteSize, using trackBasedLogicalHeight
        to compute track sizes again to make sure the height is distributed properly.
        (WebCore::RenderGrid::computeAutoRepeatTracksCount const): Because size containment's content was empty,
        the repeat tracks count is always 0.
        * rendering/RenderImage.cpp:
        (WebCore::RenderImage::computeIntrinsicRatioInformation const): This is handled in RenderReplaced::computeIntrinsicRatioInformation instead.
        * rendering/RenderListBox.cpp:
        (WebCore::RenderListBox::computeIntrinsicLogicalWidths const): The widths of size containment box are optionsSpacingHorizontal.
        * rendering/RenderMenuList.cpp:
        (RenderMenuList::computeIntrinsicLogicalWidths const): The widths of size containment box are theme.minimumMenuListSize.
        * rendering/RenderMultiColumnFlow.cpp:
        (WebCore::RenderMultiColumnFlow::updateSpaceShortageForSizeContainment): Set m_spaceShortageForSizeContainment.
        * rendering/RenderMultiColumnFlow.h:
        * rendering/RenderMultiColumnSet.cpp:
        (WebCore::RenderMultiColumnSet::RenderMultiColumnSet):
        (WebCore::RenderMultiColumnSet::calculateBalancedHeight const): Add m_spaceShortageForSizeContainment to the column height.
        (WebCore::RenderMultiColumnSet::prepareForLayout): Reset m_spaceShortageForSizeContainment.
        * rendering/RenderMultiColumnSet.h:
        * rendering/RenderObject.h:
        (WebCore::RenderObject::isAtomicInlineLevelBox const):
        (WebCore::RenderObject::shouldApplySizeContainment const): Check if this is a size containment box.
        * rendering/RenderReplaced.cpp:
        (WebCore::RenderReplaced::computeAspectRatioInformationForRenderBox const):
        (WebCore::RenderReplaced::computeIntrinsicRatioInformation const): Use the empty intrinsicSize.
        * rendering/RenderReplaced.h: The intrinsicSize of size containment is (0, 0).
        * rendering/RenderSlider.cpp:
        (WebCore::RenderSlider::computeIntrinsicLogicalWidths const): Ditto.
        * rendering/RenderTextControl.cpp:
        (WebCore::RenderTextControl::computeIntrinsicLogicalWidths const): Ditto.
        * rendering/RenderVideo.cpp:
        (WebCore::RenderVideo::calculateIntrinsicSize): Ditto.
        * rendering/svg/RenderSVGRoot.cpp:
        (WebCore::RenderSVGRoot::computeIntrinsicRatioInformation const): Handled in RenderReplaced::computeIntrinsicRatioInformation instead.

2021-04-12  Rob Buis  <rbuis@igalia.com>

        Clamp overridingContentLogicalWidth/Height to zero




    Vector<GridTrack>& allTracks = tracks(m_direction);
    for (auto& track : allTracks) {
        ASSERT(m_strategy->isComputingSizeContainment() || !track.infiniteGrowthPotential());
        m_minContentSize += track.baseSize();
        m_maxContentSize += track.growthLimitIsInfinite() ? track.baseSize() : track.growthLimit();
        // The growth limit caps must be cleared now in order to properly sort
        // tracks by growth potential on an eventual "Maximize Tracks".
        track.setGrowthLimitCap(WTF::nullopt);

    double findUsedFlexFraction(Vector<unsigned>& flexibleSizedTracksIndex, GridTrackSizingDirection, Optional<LayoutUnit> freeSpace) const override;
    bool recomputeUsedFlexFractionIfNeeded(double& flexFraction, LayoutUnit& totalGrowth) const override;
    LayoutUnit freeSpaceForStretchAutoTracksStep() const override;
    bool isComputingSizeContainment() const override { return renderGrid()->shouldApplySizeContainment(); }
};

void IndefiniteSizeStrategy::layoutGridItemForMinSizeComputation(RenderBox& child, bool overrideSizeHasChanged) const

    LayoutUnit freeSpaceForStretchAutoTracksStep() const override;
    LayoutUnit minContentForChild(RenderBox&) const override;
    LayoutUnit minLogicalSizeForChild(RenderBox&, const Length& childMinSize, Optional<LayoutUnit> availableSize) const override;
    bool isComputingSizeContainment() const override { return false; }
};

LayoutUnit IndefiniteSizeStrategy::freeSpaceForStretchAutoTracksStep() const


void GridTrackSizingAlgorithm::resolveIntrinsicTrackSizes()
{
    Vector<GridItemWithSpan> itemsSortedByIncreasingSpan;
    HashSet<RenderBox*> itemsSet;
    Vector<GridTrack>& allTracks = tracks(m_direction);
    if (!m_strategy->isComputingSizeContainment()) {
        Vector<GridItemWithSpan> itemsSortedByIncreasingSpan;
        HashSet<RenderBox*> itemsSet;
        if (m_grid.hasGridItems()) {
            for (auto trackIndex : m_contentSizedTracksIndex) {
                GridIterator iterator(m_grid, m_direction, trackIndex);
                GridTrack& track = allTracks[trackIndex];

                while (auto* gridItem = iterator.nextGridItem()) {
                    if (itemsSet.add(gridItem).isNewEntry) {
                        const GridSpan& span = m_grid.gridItemSpan(*gridItem, m_direction);
                        if (span.integerSpan() == 1)
                            sizeTrackToFitNonSpanningItem(span, *gridItem, track);
                        else if (!spanningItemCrossesFlexibleSizedTracks(span))
                            itemsSortedByIncreasingSpan.append(GridItemWithSpan(*gridItem, span));
                    }
                }
            }
            std::sort(itemsSortedByIncreasingSpan.begin(), itemsSortedByIncreasingSpan.end());
        }
        std::sort(itemsSortedByIncreasingSpan.begin(), itemsSortedByIncreasingSpan.end());
    }

        auto it = itemsSortedByIncreasingSpan.begin();
        auto end = itemsSortedByIncreasingSpan.end();
        while (it != end) {
            GridItemsSpanGroupRange spanGroupRange = { it, std::upper_bound(it, end, *it) };
            increaseSizesToAccommodateSpanningItems<ResolveIntrinsicMinimums>(spanGroupRange);
            increaseSizesToAccommodateSpanningItems<ResolveContentBasedMinimums>(spanGroupRange);
            increaseSizesToAccommodateSpanningItems<ResolveMaxContentMinimums>(spanGroupRange);
            increaseSizesToAccommodateSpanningItems<ResolveIntrinsicMaximums>(spanGroupRange);
            increaseSizesToAccommodateSpanningItems<ResolveMaxContentMaximums>(spanGroupRange);
            it = spanGroupRange.rangeEnd;
        }
    }

    for (auto trackIndex : m_contentSizedTracksIndex) {

        m_sizingState = RowSizingFirstIteration;
        return;
    case RowSizingFirstIteration:
        if (!m_strategy->isComputingSizeContainment())
            m_sizingState = ColumnSizingSecondIteration;
        return;
    case ColumnSizingSecondIteration:
        m_sizingState = RowSizingSecondIteration;


    // Step 3.
    m_strategy->maximizeTracks(tracks(m_direction), m_direction == ForColumns ? m_freeSpaceColumns : m_freeSpaceRows);
    if (m_strategy->isComputingSizeContainment())
        return;

    // Step 4.
    stretchFlexibleTracks(initialFreeSpace);

Lines 261-266 public: a/Source/WebCore/rendering/GridTrackSizingAlgorithm.h_sec1
- a/Source/WebCore/rendering/GridTrackSizingAlgorithm.h +1 lines
261	virtual double findUsedFlexFraction(Vector<unsigned>& flexibleSizedTracksIndex, GridTrackSizingDirection, Optional<LayoutUnit> initialFreeSpace) const = 0;	261	virtual double findUsedFlexFraction(Vector<unsigned>& flexibleSizedTracksIndex, GridTrackSizingDirection, Optional<LayoutUnit> initialFreeSpace) const = 0;
262	virtual bool recomputeUsedFlexFractionIfNeeded(double& flexFraction, LayoutUnit& totalGrowth) const = 0;	262	virtual bool recomputeUsedFlexFractionIfNeeded(double& flexFraction, LayoutUnit& totalGrowth) const = 0;
263	virtual LayoutUnit freeSpaceForStretchAutoTracksStep() const = 0;	263	virtual LayoutUnit freeSpaceForStretchAutoTracksStep() const = 0;
		264	virtual bool isComputingSizeContainment() const = 0;
264		265
265	protected:	266	protected:
266	GridTrackSizingAlgorithmStrategy(GridTrackSizingAlgorithm& algorithm)	267	GridTrackSizingAlgorithmStrategy(GridTrackSizingAlgorithm& algorithm)

Lines 1073-1078 void RenderBlock::layoutPositionedObject(RenderBox& r, bool relayoutChildren, bo a/Source/WebCore/rendering/RenderBlock.cpp_sec1
- a/Source/WebCore/rendering/RenderBlock.cpp -2 / +5 lines
1073	r.setNeedsLayout(MarkOnlyThis);	1073	r.setNeedsLayout(MarkOnlyThis);
1074	r.layoutIfNeeded();	1074	r.layoutIfNeeded();
1075	}	1075	}
		1076
		1077	if (view().frameView().layoutContext().layoutState()->isPaginated() && is<RenderBlockFlow>(*this))
		1078	downcast<RenderBlockFlow>(*this).adjustSizeContainmentChildForPagination(r, r.logicalTop());
1076	}	1079	}
1077		1080
1078	void RenderBlock::layoutPositionedObjects(bool relayoutChildren, bool fixedPositionObjectsOnly)	1081	void RenderBlock::layoutPositionedObjects(bool relayoutChildren, bool fixedPositionObjectsOnly)
Lines 2282-2289 void RenderBlock::offsetForContents(LayoutPoint& offset) const a/Source/WebCore/rendering/RenderBlock.cpp_sec2
2282	void RenderBlock::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const	2285	void RenderBlock::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
2283	{	2286	{
2284	ASSERT(!childrenInline());	2287	ASSERT(!childrenInline());
2285		2288	if (!shouldApplySizeContainment())
2286	computeBlockPreferredLogicalWidths(minLogicalWidth, maxLogicalWidth);	2289	computeBlockPreferredLogicalWidths(minLogicalWidth, maxLogicalWidth);
2287		2290
2288	maxLogicalWidth = std::max(minLogicalWidth, maxLogicalWidth);	2291	maxLogicalWidth = std::max(minLogicalWidth, maxLogicalWidth);
2289		2292

Lines 339-348 void RenderBlockFlow::adjustIntrinsicLogicalWidthsForColumns(LayoutUnit& minLogi a/Source/WebCore/rendering/RenderBlockFlow.cpp_sec1
- a/Source/WebCore/rendering/RenderBlockFlow.cpp -4 / +27 lines
339		339
340	void RenderBlockFlow::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const	340	void RenderBlockFlow::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
341	{	341	{
342	if (childrenInline())	342	if (!shouldApplySizeContainment()) {
343	computeInlinePreferredLogicalWidths(minLogicalWidth, maxLogicalWidth);	343	if (childrenInline())
344	else	344	computeInlinePreferredLogicalWidths(minLogicalWidth, maxLogicalWidth);
345	computeBlockPreferredLogicalWidths(minLogicalWidth, maxLogicalWidth);	345	else
		346	computeBlockPreferredLogicalWidths(minLogicalWidth, maxLogicalWidth);
		347	}
346		348
347	maxLogicalWidth = std::max(minLogicalWidth, maxLogicalWidth);	349	maxLogicalWidth = std::max(minLogicalWidth, maxLogicalWidth);
348		350
Lines 1662-1667 LayoutUnit RenderBlockFlow::adjustBlockChildForPagination(LayoutUnit logicalTopA a/Source/WebCore/rendering/RenderBlockFlow.cpp_sec2
1662	}	1664	}
1663	}	1665	}
1664		1666
		1667	if (child.shouldApplySizeContainment())
		1668	adjustSizeContainmentChildForPagination(child, result);
		1669
1665	// For replaced elements and scrolled elements, we want to shift them to the next page if they don't fit on the current one.	1670	// For replaced elements and scrolled elements, we want to shift them to the next page if they don't fit on the current one.
1666	LayoutUnit logicalTopBeforeUnsplittableAdjustment = result;	1671	LayoutUnit logicalTopBeforeUnsplittableAdjustment = result;
1667	LayoutUnit logicalTopAfterUnsplittableAdjustment = adjustForUnsplittableChild(child, result);	1672	LayoutUnit logicalTopAfterUnsplittableAdjustment = adjustForUnsplittableChild(child, result);
Lines 2047-2052 LayoutUnit RenderBlockFlow::logicalHeightForChildForFragmentation(const RenderBo a/Source/WebCore/rendering/RenderBlockFlow.cpp_sec3
2047	return logicalHeightForChild(child);	2052	return logicalHeightForChild(child);
2048	}	2053	}
2049		2054
		2055	void RenderBlockFlow::adjustSizeContainmentChildForPagination(RenderBox& child, LayoutUnit offset)
		2056	{
		2057	if (!child.shouldApplySizeContainment())
		2058	return;
		2059
		2060	LayoutUnit childOverflowHeight = child.isHorizontalWritingMode() ? child.layoutOverflowRect().maxY() : child.layoutOverflowRect().maxX();
		2061	LayoutUnit childLogicalHeight = std::max(child.logicalHeight(), childOverflowHeight);
		2062
		2063	LayoutUnit remainingLogicalHeight = pageRemainingLogicalHeightForOffset(offset, ExcludePageBoundary);
		2064
		2065	LayoutUnit spaceShortage = childLogicalHeight - remainingLogicalHeight;
		2066	if (spaceShortage <= 0)
		2067	return;
		2068
		2069	if (RenderFragmentedFlow* fragmentedFlow = enclosingFragmentedFlow())
		2070	fragmentedFlow->updateSpaceShortageForSizeContainment(this, offsetFromLogicalTopOfFirstPage() + offset, spaceShortage);
		2071	}
		2072
2050	void RenderBlockFlow::layoutLineGridBox()	2073	void RenderBlockFlow::layoutLineGridBox()
2051	{	2074	{
2052	if (style().lineGrid() == RenderStyle::initialLineGrid()) {	2075	if (style().lineGrid() == RenderStyle::initialLineGrid()) {

Lines 398-403 public: a/Source/WebCore/rendering/RenderBlockFlow.h_sec1
- a/Source/WebCore/rendering/RenderBlockFlow.h +2 lines
398	// column balancer to help set a good minimum column height.	398	// column balancer to help set a good minimum column height.
399	void updateMinimumPageHeight(LayoutUnit offset, LayoutUnit minHeight);	399	void updateMinimumPageHeight(LayoutUnit offset, LayoutUnit minHeight);
400		400
		401	void adjustSizeContainmentChildForPagination(RenderBox& child, LayoutUnit offset);
		402
401	void addFloatsToNewParent(RenderBlockFlow& toBlockFlow) const;	403	void addFloatsToNewParent(RenderBlockFlow& toBlockFlow) const;
402		404
403	LayoutUnit endPaddingWidthForCaret() const;	405	LayoutUnit endPaddingWidthForCaret() const;

Lines 2876-2881 void RenderBox::cacheIntrinsicContentLogicalHeightForFlexItem(LayoutUnit height) a/Source/WebCore/rendering/RenderBox.cpp_sec1
- a/Source/WebCore/rendering/RenderBox.cpp -1 / +8 lines
2876		2876
2877	void RenderBox::updateLogicalHeight()	2877	void RenderBox::updateLogicalHeight()
2878	{	2878	{
		2879	if (shouldApplySizeContainment() && !isRenderGrid()) {
		2880	// borderAndPaddingLogicalHeight contains intrinsicBorderForFieldset() which add extra border for fieldset, so we can't use it directly.
		2881	auto borderAndPading = RenderBox::borderBefore() + RenderBox::paddingBefore() + RenderBox::borderAfter() + RenderBox::paddingAfter();
		2882	setLogicalHeight(borderAndPading + scrollbarLogicalHeight());
		2883	}
		2884
2879	cacheIntrinsicContentLogicalHeightForFlexItem(contentLogicalHeight());	2885	cacheIntrinsicContentLogicalHeightForFlexItem(contentLogicalHeight());
2880	auto computedValues = computeLogicalHeight(logicalHeight(), logicalTop());	2886	auto computedValues = computeLogicalHeight(logicalHeight(), logicalTop());
2881	setLogicalHeight(computedValues.m_extent);	2887	setLogicalHeight(computedValues.m_extent);
Lines 4856-4862 bool RenderBox::isUnsplittableForPagination() const a/Source/WebCore/rendering/RenderBox.cpp_sec2
4856	return isReplaced()	4862	return isReplaced()
4857	\|\| hasUnsplittableScrollingOverflow()	4863	\|\| hasUnsplittableScrollingOverflow()
4858	\|\| (parent() && isWritingModeRoot())	4864	\|\| (parent() && isWritingModeRoot())
4859	\|\| (isFloating() && style().styleType() == PseudoId::FirstLetter && style().initialLetterDrop() > 0);	4865	\|\| (isFloating() && style().styleType() == PseudoId::FirstLetter && style().initialLetterDrop() > 0)
		4866	\|\| shouldApplySizeContainment();
4860	}	4867	}
4861		4868
4862	LayoutUnit RenderBox::lineHeight(bool /firstLine/, LineDirectionMode direction, LinePositionMode /linePositionMode/) const	4869	LayoutUnit RenderBox::lineHeight(bool /firstLine/, LineDirectionMode direction, LinePositionMode /linePositionMode/) const




void RenderDeprecatedFlexibleBox::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
{
    if (!shouldApplySizeContainment()) {
        if (hasMultipleLines() || isVertical()) {
            for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
                if (childDoesNotAffectWidthOrFlexing(child))
                    continue;

                LayoutUnit margin = marginWidthForChild(child);
                LayoutUnit width = child->minPreferredLogicalWidth() + margin;
                minLogicalWidth = std::max(width, minLogicalWidth);

                width = child->maxPreferredLogicalWidth() + margin;
                maxLogicalWidth = std::max(width, maxLogicalWidth);
            }
        } else {
            for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
                if (childDoesNotAffectWidthOrFlexing(child))
                    continue;

                LayoutUnit margin = marginWidthForChild(child);
                minLogicalWidth += child->minPreferredLogicalWidth() + margin;
                maxLogicalWidth += child->maxPreferredLogicalWidth() + margin;
            }
        }
    }


Lines 197-202 void RenderFileUploadControl::paintObject(PaintInfo& paintInfo, const LayoutPoin a/Source/WebCore/rendering/RenderFileUploadControl.cpp_sec1
- a/Source/WebCore/rendering/RenderFileUploadControl.cpp +2 lines
197		197
198	void RenderFileUploadControl::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const	198	void RenderFileUploadControl::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
199	{	199	{
		200	if (shouldApplySizeContainment())
		201	return;
200	// Figure out how big the filename space needs to be for a given number of characters	202	// Figure out how big the filename space needs to be for a given number of characters
201	// (using "0" as the nominal character).	203	// (using "0" as the nominal character).
202	const UChar character = '0';	204	const UChar character = '0';




void RenderFlexibleBox::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
{
    if (!shouldApplySizeContainment()) {
        LayoutUnit childMinWidth;
        LayoutUnit childMaxWidth;
        bool hadExcludedChildren = computePreferredWidthsForExcludedChildren(childMinWidth, childMaxWidth);

        // FIXME: We're ignoring flex-basis here and we shouldn't. We can't start
        // honoring it though until the flex shorthand stops setting it to 0. See
        // https://bugs.webkit.org/show_bug.cgi?id=116117 and
        // https://crbug.com/240765.
        size_t numItemsWithNormalLayout = 0;
        for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
            if (child->isOutOfFlowPositioned() || child->isExcludedFromNormalLayout())
                continue;
            ++numItemsWithNormalLayout;

            LayoutUnit margin = marginIntrinsicLogicalWidthForChild(*child);
            
            LayoutUnit minPreferredLogicalWidth;
            LayoutUnit maxPreferredLogicalWidth;
            computeChildPreferredLogicalWidths(*child, minPreferredLogicalWidth, maxPreferredLogicalWidth);
            
            minPreferredLogicalWidth += margin;
            maxPreferredLogicalWidth += margin;

            if (!isColumnFlow()) {
                maxLogicalWidth += maxPreferredLogicalWidth;
                if (isMultiline()) {
                    // For multiline, the min preferred width is if you put a break between
                    // each item.
                    minLogicalWidth = std::max(minLogicalWidth, minPreferredLogicalWidth);
                } else
                    minLogicalWidth += minPreferredLogicalWidth;
            } else {
                minLogicalWidth = std::max(minPreferredLogicalWidth, minLogicalWidth);
                maxLogicalWidth = std::max(maxPreferredLogicalWidth, maxLogicalWidth);
            }
        }
    }

        if (!isColumnFlow() && numItemsWithNormalLayout > 1) {
            LayoutUnit inlineGapSize = (numItemsWithNormalLayout - 1) * computeGap(GapType::BetweenItems);
            maxLogicalWidth += inlineGapSize;
            if (!isMultiline())
                minLogicalWidth += inlineGapSize;
        }

        maxLogicalWidth = std::max(minLogicalWidth, maxLogicalWidth);
        
        // Due to negative margins, it is possible that we calculated a negative
        // intrinsic width. Make sure that we never return a negative width.
        minLogicalWidth = std::max(0_lu, minLogicalWidth);
        maxLogicalWidth = std::max(0_lu, maxLogicalWidth);
        
        if (hadExcludedChildren) {
            minLogicalWidth = std::max(minLogicalWidth, childMinWidth);
            maxLogicalWidth = std::max(maxLogicalWidth, childMaxWidth);
        }
    }

    LayoutUnit scrollbarWidth(scrollbarLogicalWidth());

Lines 102-107 public: a/Source/WebCore/rendering/RenderFragmentedFlow.h_sec1
- a/Source/WebCore/rendering/RenderFragmentedFlow.h +2 lines
102	virtual void setPageBreak(const RenderBlock, LayoutUnit /offset/, LayoutUnit /spaceShortage*/) { }	102	virtual void setPageBreak(const RenderBlock, LayoutUnit /offset/, LayoutUnit /spaceShortage*/) { }
103	virtual void updateMinimumPageHeight(const RenderBlock, LayoutUnit /offset/, LayoutUnit /minHeight*/) { }	103	virtual void updateMinimumPageHeight(const RenderBlock, LayoutUnit /offset/, LayoutUnit /minHeight*/) { }
104		104
		105	virtual void updateSpaceShortageForSizeContainment(const RenderBlock, LayoutUnit /offset/, LayoutUnit /shortage*/) { }
		106
105	virtual RenderFragmentContainer* fragmentAtBlockOffset(const RenderBox*, LayoutUnit, bool extendLastFragment = false) const;	107	virtual RenderFragmentContainer* fragmentAtBlockOffset(const RenderBox*, LayoutUnit, bool extendLastFragment = false) const;
106		108
107	bool fragmentsHaveUniformLogicalWidth() const { return m_fragmentsHaveUniformLogicalWidth; }	109	bool fragmentsHaveUniformLogicalWidth() const { return m_fragmentsHaveUniformLogicalWidth; }

Lines 250-260 void RenderGrid::layoutBlock(bool relayoutChildren, LayoutUnit) a/Source/WebCore/rendering/RenderGrid.cpp_sec1
- a/Source/WebCore/rendering/RenderGrid.cpp -2 / +13 lines
250		250
251	// 2- Next, the track sizing algorithm resolves the sizes of the grid rows,	251	// 2- Next, the track sizing algorithm resolves the sizes of the grid rows,
252	// using the grid column sizes calculated in the previous step.	252	// using the grid column sizes calculated in the previous step.
253	if (!hasDefiniteLogicalHeight)	253	bool shouldRecomputeHeight = false;
		254	if (!hasDefiniteLogicalHeight) {
254	computeTrackSizesForIndefiniteSize(m_trackSizingAlgorithm, ForRows);	255	computeTrackSizesForIndefiniteSize(m_trackSizingAlgorithm, ForRows);
255	else	256	if (shouldApplySizeContainment())
		257	shouldRecomputeHeight = true;
		258	} else
256	computeTrackSizesForDefiniteSize(ForRows, availableLogicalHeight(ExcludeMarginBorderPadding));	259	computeTrackSizesForDefiniteSize(ForRows, availableLogicalHeight(ExcludeMarginBorderPadding));
257	LayoutUnit trackBasedLogicalHeight = m_trackSizingAlgorithm.computeTrackBasedSize() + borderAndPaddingLogicalHeight() + scrollbarLogicalHeight();	260	LayoutUnit trackBasedLogicalHeight = m_trackSizingAlgorithm.computeTrackBasedSize() + borderAndPaddingLogicalHeight() + scrollbarLogicalHeight();
		261	if (shouldRecomputeHeight)
		262	computeTrackSizesForDefiniteSize(ForRows, trackBasedLogicalHeight);
		263
258	setLogicalHeight(trackBasedLogicalHeight);	264	setLogicalHeight(trackBasedLogicalHeight);
259		265
260	LayoutUnit oldClientAfterEdge = clientLogicalBottom();	266	LayoutUnit oldClientAfterEdge = clientLogicalBottom();
Lines 455-460 unsigned RenderGrid::computeAutoRepeatTracksCount(GridTrackSizingDirection direc a/Source/WebCore/rendering/RenderGrid.cpp_sec2
455	{	461	{
456	ASSERT(!availableSize \|\| availableSize.value() != -1);	462	ASSERT(!availableSize \|\| availableSize.value() != -1);
457	bool isRowAxis = direction == ForColumns;	463	bool isRowAxis = direction == ForColumns;
		464	if (shouldApplySizeContainment()
		465	&& ((isRowAxis && style().gridAutoRepeatColumnsType() == AutoRepeatType::Fit)
		466	\|\| (!isRowAxis && style().gridAutoRepeatRowsType() == AutoRepeatType::Fit)))
		467	return 0;
		468
458	const auto& autoRepeatTracks = isRowAxis ? style().gridAutoRepeatColumns() : style().gridAutoRepeatRows();	469	const auto& autoRepeatTracks = isRowAxis ? style().gridAutoRepeatColumns() : style().gridAutoRepeatRows();
459	unsigned autoRepeatTrackListLength = autoRepeatTracks.size();	470	unsigned autoRepeatTrackListLength = autoRepeatTracks.size();
460		471

Lines 844-849 void RenderImage::layoutShadowContent(const LayoutSize& oldSize) a/Source/WebCore/rendering/RenderImage.cpp_sec1
- a/Source/WebCore/rendering/RenderImage.cpp +1 lines
844		844
845	void RenderImage::computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio) const	845	void RenderImage::computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio) const
846	{	846	{
		847	ASSERT(!shouldApplySizeContainment());
847	RenderReplaced::computeIntrinsicRatioInformation(intrinsicSize, intrinsicRatio);	848	RenderReplaced::computeIntrinsicRatioInformation(intrinsicSize, intrinsicRatio);
848		849
849	// Our intrinsicSize is empty if we're rendering generated images with relative width/height. Figure out the right intrinsic size to use.	850	// Our intrinsicSize is empty if we're rendering generated images with relative width/height. Figure out the right intrinsic size to use.

Lines 211-217 void RenderListBox::scrollToRevealSelection() a/Source/WebCore/rendering/RenderListBox.cpp_sec1
- a/Source/WebCore/rendering/RenderListBox.cpp -1 / +1 lines
211		211
212	void RenderListBox::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const	212	void RenderListBox::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
213	{	213	{
214	maxLogicalWidth = m_optionsWidth + 2 * optionsSpacingHorizontal;	214	maxLogicalWidth = shouldApplySizeContainment() ? 2 * optionsSpacingHorizontal : m_optionsWidth + 2 * optionsSpacingHorizontal;
215	if (m_vBar)	215	if (m_vBar)
216	maxLogicalWidth += m_vBar->width();	216	maxLogicalWidth += m_vBar->width();
217	if (!style().width().isPercentOrCalculated())	217	if (!style().width().isPercentOrCalculated())




void RenderMenuList::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
{
    maxLogicalWidth = shouldApplySizeContainment() ? theme().minimumMenuListSize(style()) : std::max(m_optionsWidth, theme().minimumMenuListSize(style()));
    maxLogicalWidth += m_innerBlock->paddingLeft() + m_innerBlock->paddingRight();
    if (!style().width().isPercentOrCalculated())
        minLogicalWidth = maxLogicalWidth;
}

Lines 203-208 void RenderMultiColumnFlow::updateMinimumPageHeight(const RenderBlock* block, La a/Source/WebCore/rendering/RenderMultiColumnFlow.cpp_sec1
- a/Source/WebCore/rendering/RenderMultiColumnFlow.cpp +6 lines
203	multicolSet->updateMinimumColumnHeight(minHeight);	203	multicolSet->updateMinimumColumnHeight(minHeight);
204	}	204	}
205		205
		206	void RenderMultiColumnFlow::updateSpaceShortageForSizeContainment(const RenderBlock* block, LayoutUnit offset, LayoutUnit shortage)
		207	{
		208	if (auto* multicolSet = downcast<RenderMultiColumnSet>(fragmentAtBlockOffset(block, offset)))
		209	multicolSet->updateSpaceShortageForSizeContainment(shortage);
		210	}
		211
206	RenderFragmentContainer* RenderMultiColumnFlow::fragmentAtBlockOffset(const RenderBox* box, LayoutUnit offset, bool extendLastFragment) const	212	RenderFragmentContainer* RenderMultiColumnFlow::fragmentAtBlockOffset(const RenderBox* box, LayoutUnit offset, bool extendLastFragment) const
207	{	213	{
208	if (!m_inLayout)	214	if (!m_inLayout)

Lines 108-113 private: a/Source/WebCore/rendering/RenderMultiColumnFlow.h_sec1
- a/Source/WebCore/rendering/RenderMultiColumnFlow.h +1 lines
108	LayoutUnit initialLogicalWidth() const override;	108	LayoutUnit initialLogicalWidth() const override;
109	void setPageBreak(const RenderBlock*, LayoutUnit offset, LayoutUnit spaceShortage) override;	109	void setPageBreak(const RenderBlock*, LayoutUnit offset, LayoutUnit spaceShortage) override;
110	void updateMinimumPageHeight(const RenderBlock*, LayoutUnit offset, LayoutUnit minHeight) override;	110	void updateMinimumPageHeight(const RenderBlock*, LayoutUnit offset, LayoutUnit minHeight) override;
		111	void updateSpaceShortageForSizeContainment(const RenderBlock*, LayoutUnit offset, LayoutUnit shortage) override;
111	RenderFragmentContainer* fragmentAtBlockOffset(const RenderBox*, LayoutUnit, bool extendLastFragment = false) const override;	112	RenderFragmentContainer* fragmentAtBlockOffset(const RenderBox*, LayoutUnit, bool extendLastFragment = false) const override;
112	void setFragmentRangeForBox(const RenderBox&, RenderFragmentContainer, RenderFragmentContainer) override;	113	void setFragmentRangeForBox(const RenderBox&, RenderFragmentContainer, RenderFragmentContainer) override;
113	bool addForcedFragmentBreak(const RenderBlock, LayoutUnit, RenderBox breakChild, bool isBefore, LayoutUnit* offsetBreakAdjustment = 0) override;	114	bool addForcedFragmentBreak(const RenderBlock, LayoutUnit, RenderBox breakChild, bool isBefore, LayoutUnit* offsetBreakAdjustment = 0) override;



    , m_maxColumnHeight(RenderFragmentedFlow::maxLogicalHeight())
    , m_minSpaceShortage(RenderFragmentedFlow::maxLogicalHeight())
    , m_minimumColumnHeight(0)
    , m_spaceShortageForSizeContainment(0)
{
}


        return std::max<LayoutUnit>(m_contentRuns[index].columnLogicalHeight(startOffset), m_minimumColumnHeight);
    }

    LayoutUnit sizeContainmentShortage = std::max<LayoutUnit>(LayoutUnit(), m_spaceShortageForSizeContainment);
    if (columnCount() <= computedColumnCount()) {
        // With the current column height, the content fits without creating overflowing columns. We're done.
        return m_computedColumnHeight + sizeContainmentShortage;
    }

    if (forcedBreaksCount() >= computedColumnCount()) {
        // Too many forced breaks to allow any implicit breaks. Initial balancing should already
        // have set a good height. There's nothing more we should do.
        return m_computedColumnHeight + sizeContainmentShortage;
    }

    // If the initial guessed column height wasn't enough, stretch it now. Stretch by the lowest

    ASSERT(m_minSpaceShortage > 0); // We should never _shrink_ the height!
    // ASSERT(m_minSpaceShortage != RenderFragmentedFlow::maxLogicalHeight()); // If this happens, we probably have a bug.
    if (m_minSpaceShortage == RenderFragmentedFlow::maxLogicalHeight())
        return m_computedColumnHeight + sizeContainmentShortage; // So bail out rather than looping infinitely.

    auto toAdd = std::max<LayoutUnit>(sizeContainmentShortage, m_minSpaceShortage);
    return m_computedColumnHeight + toAdd;
}

void RenderMultiColumnSet::clearForcedBreaks()

    // Nuke previously stored minimum column height. Contents may have changed for all we know.
    m_minimumColumnHeight = 0;

    m_spaceShortageForSizeContainment = 0;

    // Start with "infinite" flow thread portion height until height is known.
    setLogicalBottomInFragmentedFlow(RenderFragmentedFlow::maxLogicalHeight());




    void updateMinimumColumnHeight(LayoutUnit height) { m_minimumColumnHeight = std::max(height, m_minimumColumnHeight); }
    LayoutUnit minimumColumnHeight() const { return m_minimumColumnHeight; }

    void updateSpaceShortageForSizeContainment(LayoutUnit shortage)
    {
        if (m_spaceShortageForSizeContainment <= 0) {
            m_spaceShortageForSizeContainment = shortage;
            return;
        }
        m_spaceShortageForSizeContainment = std::min(shortage, m_spaceShortageForSizeContainment);
    }

    unsigned forcedBreaksCount() const { return m_contentRuns.size(); }
    void clearForcedBreaks();
    void addForcedBreak(LayoutUnit offsetFromFirstPage);

    LayoutUnit m_maxColumnHeight; // Maximum column height allowed.
    LayoutUnit m_minSpaceShortage; // The smallest amout of space shortage that caused a column break.
    LayoutUnit m_minimumColumnHeight;
    LayoutUnit m_spaceShortageForSizeContainment; // The shortage space that keeps size containment monolithic.

    // A run of content without explicit (forced) breaks; i.e. a flow thread portion between two
    // explicit breaks, between flow thread start and an explicit break, between an explicit break




    virtual String debugDescription() const;

    bool isAtomicInlineLevelBox() const
    {
        return style().isDisplayInlineType() && !(style().display() == DisplayType::Inline && !isReplaced());
    }

    bool shouldApplySizeContainment() const
    {
        return style().contain().contains(Containment::Size) && (!isInline() || isAtomicInlineLevelBox())
            && !isRubyText() && (!isTablePart() || isTableCaption()) && !isTable();
    }

protected:
    //////////////////////////////////////////
    // Helper functions. Dangerous to use!

Lines 389-395 bool RenderReplaced::setNeedsLayoutIfNeededAfterIntrinsicSizeChange() a/Source/WebCore/rendering/RenderReplaced.cpp_sec1
- a/Source/WebCore/rendering/RenderReplaced.cpp -2 / +4 lines
389	void RenderReplaced::computeAspectRatioInformationForRenderBox(RenderBox* contentRenderer, FloatSize& constrainedSize, double& intrinsicRatio) const	389	void RenderReplaced::computeAspectRatioInformationForRenderBox(RenderBox* contentRenderer, FloatSize& constrainedSize, double& intrinsicRatio) const
390	{	390	{
391	FloatSize intrinsicSize;	391	FloatSize intrinsicSize;
392	if (contentRenderer) {	392	if (shouldApplySizeContainment())
		393	RenderReplaced::computeIntrinsicRatioInformation(intrinsicSize, intrinsicRatio);
		394	else if (contentRenderer) {
393	contentRenderer->computeIntrinsicRatioInformation(intrinsicSize, intrinsicRatio);	395	contentRenderer->computeIntrinsicRatioInformation(intrinsicSize, intrinsicRatio);
394		396
395	if (style().aspectRatioType() == AspectRatioType::Ratio \|\| (style().aspectRatioType() == AspectRatioType::AutoAndRatio && !intrinsicRatio))	397	if (style().aspectRatioType() == AspectRatioType::Ratio \|\| (style().aspectRatioType() == AspectRatioType::AutoAndRatio && !intrinsicRatio))
Lines 477-483 RoundedRect RenderReplaced::roundedContentBoxRect() const a/Source/WebCore/rendering/RenderReplaced.cpp_sec2
477	void RenderReplaced::computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio) const	479	void RenderReplaced::computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio) const
478	{	480	{
479	// If there's an embeddedContentBox() of a remote, referenced document available, this code-path should never be used.	481	// If there's an embeddedContentBox() of a remote, referenced document available, this code-path should never be used.
480	ASSERT(!embeddedContentBox());	482	ASSERT(!embeddedContentBox() \|\| shouldApplySizeContainment());
481	intrinsicSize = FloatSize(intrinsicLogicalWidth(), intrinsicLogicalHeight());	483	intrinsicSize = FloatSize(intrinsicLogicalWidth(), intrinsicLogicalHeight());
482		484
483	if (style().hasAspectRatio()) {	485	if (style().hasAspectRatio()) {

Lines 40-46 public: a/Source/WebCore/rendering/RenderReplaced.h_sec1
- a/Source/WebCore/rendering/RenderReplaced.h -1 / +6 lines
40	bool hasReplacedLogicalHeight() const;	40	bool hasReplacedLogicalHeight() const;
41	bool setNeedsLayoutIfNeededAfterIntrinsicSizeChange();	41	bool setNeedsLayoutIfNeededAfterIntrinsicSizeChange();
42		42
43	LayoutSize intrinsicSize() const final { return m_intrinsicSize; }	43	LayoutSize intrinsicSize() const final
		44	{
		45	if (shouldApplySizeContainment())
		46	return LayoutSize();
		47	return m_intrinsicSize;
		48	}
44		49
45	RoundedRect roundedContentBoxRect() const;	50	RoundedRect roundedContentBoxRect() const;
46		51

Lines 69-74 LayoutUnit RenderSlider::baselinePosition(FontBaseline, bool /firstLine/, Line a/Source/WebCore/rendering/RenderSlider.cpp_sec1
- a/Source/WebCore/rendering/RenderSlider.cpp +2 lines
69		69
70	void RenderSlider::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const	70	void RenderSlider::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
71	{	71	{
		72	if (shouldApplySizeContainment())
		73	return;
72	maxLogicalWidth = defaultTrackLength * style().effectiveZoom();	74	maxLogicalWidth = defaultTrackLength * style().effectiveZoom();
73	if (!style().width().isPercentOrCalculated())	75	if (!style().width().isPercentOrCalculated())
74	minLogicalWidth = maxLogicalWidth;	76	minLogicalWidth = maxLogicalWidth;

Lines 156-161 float RenderTextControl::scaleEmToUnits(int x) const a/Source/WebCore/rendering/RenderTextControl.cpp_sec1
- a/Source/WebCore/rendering/RenderTextControl.cpp +2 lines
156		156
157	void RenderTextControl::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const	157	void RenderTextControl::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
158	{	158	{
		159	if (shouldApplySizeContainment())
		160	return;
159	// Use average character width. Matches IE.	161	// Use average character width. Matches IE.
160	maxLogicalWidth = preferredContentLogicalWidth(const_cast<RenderTextControl*>(this)->getAverageCharWidth());	162	maxLogicalWidth = preferredContentLogicalWidth(const_cast<RenderTextControl*>(this)->getAverageCharWidth());
161	if (RenderBox* innerTextRenderBox = innerTextElement()->renderBox())	163	if (RenderBox* innerTextRenderBox = innerTextElement()->renderBox())

Lines 123-128 bool RenderVideo::updateIntrinsicSize() a/Source/WebCore/rendering/RenderVideo.cpp_sec1
- a/Source/WebCore/rendering/RenderVideo.cpp +3 lines
123		123
124	LayoutSize RenderVideo::calculateIntrinsicSize()	124	LayoutSize RenderVideo::calculateIntrinsicSize()
125	{	125	{
		126	if (shouldApplySizeContainment())
		127	return LayoutSize();
		128
126	// Spec text from 4.8.6	129	// Spec text from 4.8.6
127	//	130	//
128	// The intrinsic width of a video element's playback area is the intrinsic width	131	// The intrinsic width of a video element's playback area is the intrinsic width

Lines 70-75 SVGSVGElement& RenderSVGRoot::svgSVGElement() const a/Source/WebCore/rendering/svg/RenderSVGRoot.cpp_sec1
- a/Source/WebCore/rendering/svg/RenderSVGRoot.cpp +2 lines
70		70
71	void RenderSVGRoot::computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio) const	71	void RenderSVGRoot::computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio) const
72	{	72	{
		73	ASSERT(!shouldApplySizeContainment());
		74
73	// Spec: http://www.w3.org/TR/SVG/coords.html#IntrinsicSizing	75	// Spec: http://www.w3.org/TR/SVG/coords.html#IntrinsicSizing
74	// SVG needs to specify how to calculate some intrinsic sizing properties to enable inclusion within other languages.	76	// SVG needs to specify how to calculate some intrinsic sizing properties to enable inclusion within other languages.
75		77



2021-04-12  Cathie Chen  <cathiechen@igalia.com>

        [CSS contain] Support contain:size
        https://bugs.webkit.org/show_bug.cgi?id=223570

        Reviewed by NOBODY (OOPS!).

        Update the test result for size containment. Added explanations for size containment tests
        that depended on other features.

        * TestExpectations:

2021-04-12  Rob Buis  <rbuis@igalia.com>

        Clamp overridingContentLogicalWidth/Height to zero



2021-04-12  Cathie Chen  <cathiechen@igalia.com>

        [CSS contain] Support contain:size
        https://bugs.webkit.org/show_bug.cgi?id=223570

        Reviewed by NOBODY (OOPS!).

        * web-platform-tests/css/css-contain/contain-size-grid-003-expected.txt:
        * web-platform-tests/css/css-contain/contain-size-grid-004-expected.txt:
        * web-platform-tests/css/css-contain/contain-size-multicol-as-flex-item-expected.txt:
        * web-platform-tests/css/css-flexbox/flex-item-contains-strict-expected.txt:

2021-04-11  Sam Weinig  <weinig@apple.com>

        Reduce compile time and binary size cost of enabling proper CSSStyleDeclaration property access behavior



imported/w3c/web-platform-tests/css/css-contain/contain-paint-stacking-context-001b.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-paint-table-001.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-paint-table-002.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-011.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-013.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-021.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-023.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-025.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-027.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-041.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-042.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-056.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-061.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-062.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-063.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-064.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-block-001.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-block-002.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-block-003.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-block-004.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-borders.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-breaks-001.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-button-001.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-button-002.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-fieldset-001.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-fieldset-002.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-fieldset-003.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-fieldset-004.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-flex-001.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-flexbox-001.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-grid-001.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-grid-002.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-grid-005.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-inline-block-001.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-inline-block-002.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-inline-block-003.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-inline-block-004.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-inline-flex-001.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-monolithic-001.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-monolithic-002.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-multicol-001.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-multicol-002.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-multicol-003.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-replaced-001.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-replaced-002.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-replaced-003a.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-replaced-003b.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-replaced-003c.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-replaced-004.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-replaced-005.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-replaced-006.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-scrollbars-001.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-scrollbars-002.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-scrollbars-003.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-select-001.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-select-002.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-select-elem-001.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-select-elem-002.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-select-elem-003.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-select-elem-004.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-select-elem-005.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-table-caption-001.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-strict-001.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-strict-002.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-strict-003.html [ ImageOnlyFailure ]

imported/w3c/web-platform-tests/css/css-contain/quote-scoping-003.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/quote-scoping-004.html [ ImageOnlyFailure ]

# Canvas doesn't get default aspect-ratio for width and height attributes.
webkit.org/b/217529 imported/w3c/web-platform-tests/css/css-flexbox/canvas-contain-size.html [ ImageOnlyFailure ]

# Content is painted on svg's padding area. 
webkit.org/b/425868 imported/w3c/web-platform-tests/css/css-contain/contain-size-replaced-002.html [ ImageOnlyFailure ]

# Multicolumn does not paint the horizontal overflow area of a relative child.
webkit.org/b/41796 imported/w3c/web-platform-tests/css/css-contain/contain-size-monolithic-002.html [ ImageOnlyFailure ]

# Buttons with auto width and height has extra margins.
imported/w3c/web-platform-tests/css/css-contain/contain-size-button-001.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-button-002.html [ ImageOnlyFailure ]

# Scrollbar displays are different.
imported/w3c/web-platform-tests/css/css-contain/contain-size-block-003.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-inline-block-003.html [ ImageOnlyFailure ]

# Select with empty content always has root linebox, so the heights are different.
imported/w3c/web-platform-tests/css/css-contain/contain-size-select-001.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-select-002.html [ ImageOnlyFailure ]

# CSS property color is not working in select elements.
imported/w3c/web-platform-tests/css/css-contain/contain-size-select-elem-001.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-contain/contain-size-select-elem-002.html [ ImageOnlyFailure ]

# @counter-style ref tests that currently fail
imported/w3c/web-platform-tests/css/css-counter-styles/armenian/css3-counter-styles-006.html [ ImageOnlyFailure ]
imported/w3c/web-platform-tests/css/css-counter-styles/armenian/css3-counter-styles-007.html [ ImageOnlyFailure ]



PASS .grid 35
PASS .grid 36
PASS .grid 37
PASS .grid 38
PASS .grid 39
    <div></div>
  </div>
width expected 0 but got 100
FAIL .grid 39 assert_equals:
<div class="grid" style="grid: auto 50px / 100px auto;" data-expected-width="100" data-expected-height="50">
  <div data-expected-width="100" data-expected-height="10" data-offset-x="0" data-offset-y="0">X</div>
  <div data-expected-width="40" data-expected-height="10" data-offset-x="100" data-offset-y="0">XX</div>
  <div data-expected-width="100" data-expected-height="50" data-offset-x="0" data-offset-y="10">XXX</div>
  <div data-expected-width="40" data-expected-height="50" data-offset-x="100" data-offset-y="10">XXXX</div>
</div>
width expected 100 but got 140

X
XX




PASS .grid 1
PASS .grid 2
<div class="grid percent min-content" data-expected-height="0" data-expected-width="0">
  <div data-expected-height="0" data-expected-width="0">XXXX</div>
</div>
width expected 0 but got 300
PASS .grid 3
PASS .grid 4
<div class="grid percent max-content" data-expected-height="0" data-expected-width="0">
  <div data-expected-height="0" data-expected-width="0">XXXX</div>
</div>
width expected 0 but got 300
PASS .grid 5
PASS .grid 6
PASS .grid 7
PASS .grid 8
<div class="grid calc min-content" data-expected-height="0" data-expected-width="0">
  <div data-expected-height="100" data-expected-width="100">XXXX</div>
</div>
width expected 0 but got 300
PASS .grid 9
PASS .grid 10
<div class="grid calc max-content" data-expected-height="0" data-expected-width="0">
  <div data-expected-height="100" data-expected-width="100">XXXX</div>
</div>
width expected 0 but got 300
PASS .grid 11
PASS .grid 12
PASS .grid 13
PASS .grid 14
<div class="grid minmax-percent-fixed min-content" data-expected-height="100" data-expected-width="0">
  <div data-expected-height="100" data-expected-width="0">XXXX</div>
</div>
width expected 0 but got 100
PASS .grid 15
PASS .grid 16
PASS .grid 17

PASS .grid 19
PASS .grid 20
PASS .grid 21
PASS .grid 22
<div class="grid minmax-fixed-percent max-content" data-expected-height="100" data-expected-width="100">
  <div data-expected-height="100" data-expected-width="100">XXXX</div>
</div>
width expected 100 but got 300
PASS .grid 23
PASS .grid 24
PASS .grid 25
PASS .grid 26
<div class="grid minmax-percent-flex min-content" data-expected-height="0" data-expected-width="0">
  <div data-expected-height="0" data-expected-width="0">XXXX</div>
</div>
width expected 0 but got 300
PASS .grid 27
PASS .grid 28
<div class="grid minmax-percent-flex max-content" data-expected-height="0" data-expected-width="0">
  <div data-expected-height="0" data-expected-width="0">XXXX</div>
</div>
width expected 0 but got 300
PASS .grid 29
PASS .grid 30
PASS .grid 31
PASS .grid 32
<div class="grid minmax-intrinsic-percent min-content" data-expected-height="0" data-expected-width="0">
  <div data-expected-height="75" data-expected-width="300">XXXX</div>
</div>
width expected 0 but got 300
PASS .grid 33
PASS .grid 34
<div class="grid minmax-intrinsic-percent max-content" data-expected-height="0" data-expected-width="0">
  <div data-expected-height="75" data-expected-width="300">XXXX</div>
</div>
width expected 0 but got 300
PASS .grid 35
PASS .grid 36
PASS .grid 37
PASS .grid 38
<div class="grid minmax-percent-intrinsic min-content" data-expected-height="0" data-expected-width="0">
  <div data-expected-height="0" data-expected-width="0">XXXX</div>
</div>
width expected 0 but got 300
PASS .grid 39
PASS .grid 40
<div class="grid minmax-percent-intrinsic max-content" data-expected-height="0" data-expected-width="0">
  <div data-expected-height="0" data-expected-width="0">XXXX</div>
</div>
width expected 0 but got 300
PASS .grid 41
PASS .grid 42
PASS .grid 43
PASS .grid 44
<div class="grid fit-content min-content" data-expected-height="0" data-expected-width="0">
  <div data-expected-height="75" data-expected-width="300">XXXX</div>
</div>
width expected 0 but got 300
PASS .grid 45
PASS .grid 46
<div class="grid fit-content max-content" data-expected-height="0" data-expected-width="0">
  <div data-expected-height="75" data-expected-width="300">XXXX</div>
</div>
width expected 0 but got 300
PASS .grid 47
PASS .grid 48
XXXX



There should be a green square below.


PASS #flex 1
<div id="flex">
  <div id="multicol" data-expected-width="100" data-expected-height="100">
    <div style="width:1000px; height:1px;"></div>
  </div>
</div>
width expected 100 but got 784





Row

PASS .inline-flex 1
PASS .inline-flex 2
  <div style="contain: strict;" data-expected-width="0" data-expected-height="0">Column</div>
</div>
width expected 0 but got 52
FAIL .inline-flex 2 assert_equals:
<div class="inline-flex" data-expected-width="0" data-expected-height="0">
  <div style="contain: strict;" data-expected-width="0" data-expected-height="0">Row</div>
</div>
width expected 0 but got 30
PASS .inline-flex 3
PASS .inline-flex 4
PASS .inline-flex 5
PASS .inline-flex 6
  <div style="contain: strict;" data-expected-width="0" data-expected-height="0">Column</div>
</div>
width expected 0 but got 52
FAIL .inline-flex 6 assert_equals:
<div class="inline-flex" style="align-items: flex-start;" data-expected-width="0" data-expected-height="0">
  <div style="contain: strict;" data-expected-width="0" data-expected-height="0">Row</div>
</div>
width expected 0 but got 30
PASS .inline-flex 7
PASS .inline-flex 8


Return to Bug 223570

Lines 736-744 void GridTrackSizingAlgorithm::computeGridContainerIntrinsicSizes() a/Source/WebCore/rendering/GridTrackSizingAlgorithm.cpp_sec1
- a/Source/WebCore/rendering/GridTrackSizingAlgorithm.cpp -29 / +36 lines
736		736
737	Vector<GridTrack>& allTracks = tracks(m_direction);	737	Vector<GridTrack>& allTracks = tracks(m_direction);
738	for (auto& track : allTracks) {	738	for (auto& track : allTracks) {
739	ASSERT(!track.infiniteGrowthPotential());	739	ASSERT(m_strategy->isComputingSizeContainment() \|\| !track.infiniteGrowthPotential());
740	m_minContentSize += track.baseSize();	740	m_minContentSize += track.baseSize();
741	m_maxContentSize += track.growthLimit();	741	m_maxContentSize += track.growthLimitIsInfinite() ? track.baseSize() : track.growthLimit();
742	// The growth limit caps must be cleared now in order to properly sort	742	// The growth limit caps must be cleared now in order to properly sort
743	// tracks by growth potential on an eventual "Maximize Tracks".	743	// tracks by growth potential on an eventual "Maximize Tracks".
744	track.setGrowthLimitCap(WTF::nullopt);	744	track.setGrowthLimitCap(WTF::nullopt);
Lines 932-937 private: a/Source/WebCore/rendering/GridTrackSizingAlgorithm.cpp_sec2
932	double findUsedFlexFraction(Vector<unsigned>& flexibleSizedTracksIndex, GridTrackSizingDirection, Optional<LayoutUnit> freeSpace) const override;	932	double findUsedFlexFraction(Vector<unsigned>& flexibleSizedTracksIndex, GridTrackSizingDirection, Optional<LayoutUnit> freeSpace) const override;
933	bool recomputeUsedFlexFractionIfNeeded(double& flexFraction, LayoutUnit& totalGrowth) const override;	933	bool recomputeUsedFlexFractionIfNeeded(double& flexFraction, LayoutUnit& totalGrowth) const override;
934	LayoutUnit freeSpaceForStretchAutoTracksStep() const override;	934	LayoutUnit freeSpaceForStretchAutoTracksStep() const override;
		935	bool isComputingSizeContainment() const override { return renderGrid()->shouldApplySizeContainment(); }
935	};	936	};
936		937
937	void IndefiniteSizeStrategy::layoutGridItemForMinSizeComputation(RenderBox& child, bool overrideSizeHasChanged) const	938	void IndefiniteSizeStrategy::layoutGridItemForMinSizeComputation(RenderBox& child, bool overrideSizeHasChanged) const
Lines 1030-1035 private: a/Source/WebCore/rendering/GridTrackSizingAlgorithm.cpp_sec3
1030	LayoutUnit freeSpaceForStretchAutoTracksStep() const override;	1031	LayoutUnit freeSpaceForStretchAutoTracksStep() const override;
1031	LayoutUnit minContentForChild(RenderBox&) const override;	1032	LayoutUnit minContentForChild(RenderBox&) const override;
1032	LayoutUnit minLogicalSizeForChild(RenderBox&, const Length& childMinSize, Optional<LayoutUnit> availableSize) const override;	1033	LayoutUnit minLogicalSizeForChild(RenderBox&, const Length& childMinSize, Optional<LayoutUnit> availableSize) const override;
		1034	bool isComputingSizeContainment() const override { return false; }
1033	};	1035	};
1034		1036
1035	LayoutUnit IndefiniteSizeStrategy::freeSpaceForStretchAutoTracksStep() const	1037	LayoutUnit IndefiniteSizeStrategy::freeSpaceForStretchAutoTracksStep() const
Lines 1146-1182 void GridTrackSizingAlgorithm::initializeTrackSizes() a/Source/WebCore/rendering/GridTrackSizingAlgorithm.cpp_sec4
1146		1148
1147	void GridTrackSizingAlgorithm::resolveIntrinsicTrackSizes()	1149	void GridTrackSizingAlgorithm::resolveIntrinsicTrackSizes()
1148	{	1150	{
1149	Vector<GridItemWithSpan> itemsSortedByIncreasingSpan;
1150	HashSet<RenderBox*> itemsSet;
1151	Vector<GridTrack>& allTracks = tracks(m_direction);	1151	Vector<GridTrack>& allTracks = tracks(m_direction);
1152	if (m_grid.hasGridItems()) {	1152	if (!m_strategy->isComputingSizeContainment()) {
1153	for (auto trackIndex : m_contentSizedTracksIndex) {	1153	Vector<GridItemWithSpan> itemsSortedByIncreasingSpan;
1154	GridIterator iterator(m_grid, m_direction, trackIndex);	1154	HashSet<RenderBox*> itemsSet;
1155	GridTrack& track = allTracks[trackIndex];	1155	if (m_grid.hasGridItems()) {
1156		1156	for (auto trackIndex : m_contentSizedTracksIndex) {
1157	while (auto* gridItem = iterator.nextGridItem()) {	1157	GridIterator iterator(m_grid, m_direction, trackIndex);
1158	if (itemsSet.add(gridItem).isNewEntry) {	1158	GridTrack& track = allTracks[trackIndex];
1159	const GridSpan& span = m_grid.gridItemSpan(*gridItem, m_direction);	1159
1160	if (span.integerSpan() == 1)	1160	while (auto* gridItem = iterator.nextGridItem()) {
1161	sizeTrackToFitNonSpanningItem(span, *gridItem, track);	1161	if (itemsSet.add(gridItem).isNewEntry) {
1162	else if (!spanningItemCrossesFlexibleSizedTracks(span))	1162	const GridSpan& span = m_grid.gridItemSpan(*gridItem, m_direction);
1163	itemsSortedByIncreasingSpan.append(GridItemWithSpan(*gridItem, span));	1163	if (span.integerSpan() == 1)
		1164	sizeTrackToFitNonSpanningItem(span, *gridItem, track);
		1165	else if (!spanningItemCrossesFlexibleSizedTracks(span))
		1166	itemsSortedByIncreasingSpan.append(GridItemWithSpan(*gridItem, span));
		1167	}
1164	}	1168	}
1165	}	1169	}
		1170	std::sort(itemsSortedByIncreasingSpan.begin(), itemsSortedByIncreasingSpan.end());
1166	}	1171	}
1167	std::sort(itemsSortedByIncreasingSpan.begin(), itemsSortedByIncreasingSpan.end());
1168	}
1169		1172
1170	auto it = itemsSortedByIncreasingSpan.begin();	1173	auto it = itemsSortedByIncreasingSpan.begin();
1171	auto end = itemsSortedByIncreasingSpan.end();	1174	auto end = itemsSortedByIncreasingSpan.end();
1172	while (it != end) {	1175	while (it != end) {
1173	GridItemsSpanGroupRange spanGroupRange = { it, std::upper_bound(it, end, *it) };	1176	GridItemsSpanGroupRange spanGroupRange = { it, std::upper_bound(it, end, *it) };
1174	increaseSizesToAccommodateSpanningItems<ResolveIntrinsicMinimums>(spanGroupRange);	1177	increaseSizesToAccommodateSpanningItems<ResolveIntrinsicMinimums>(spanGroupRange);
1175	increaseSizesToAccommodateSpanningItems<ResolveContentBasedMinimums>(spanGroupRange);	1178	increaseSizesToAccommodateSpanningItems<ResolveContentBasedMinimums>(spanGroupRange);
1176	increaseSizesToAccommodateSpanningItems<ResolveMaxContentMinimums>(spanGroupRange);	1179	increaseSizesToAccommodateSpanningItems<ResolveMaxContentMinimums>(spanGroupRange);
1177	increaseSizesToAccommodateSpanningItems<ResolveIntrinsicMaximums>(spanGroupRange);	1180	increaseSizesToAccommodateSpanningItems<ResolveIntrinsicMaximums>(spanGroupRange);
1178	increaseSizesToAccommodateSpanningItems<ResolveMaxContentMaximums>(spanGroupRange);	1181	increaseSizesToAccommodateSpanningItems<ResolveMaxContentMaximums>(spanGroupRange);
1179	it = spanGroupRange.rangeEnd;	1182	it = spanGroupRange.rangeEnd;
		1183	}
1180	}	1184	}
1181		1185
1182	for (auto trackIndex : m_contentSizedTracksIndex) {	1186	for (auto trackIndex : m_contentSizedTracksIndex) {
Lines 1239-1245 void GridTrackSizingAlgorithm::advanceNextState() a/Source/WebCore/rendering/GridTrackSizingAlgorithm.cpp_sec5
1239	m_sizingState = RowSizingFirstIteration;	1243	m_sizingState = RowSizingFirstIteration;
1240	return;	1244	return;
1241	case RowSizingFirstIteration:	1245	case RowSizingFirstIteration:
1242	m_sizingState = ColumnSizingSecondIteration;	1246	if (!m_strategy->isComputingSizeContainment())
		1247	m_sizingState = ColumnSizingSecondIteration;
1243	return;	1248	return;
1244	case ColumnSizingSecondIteration:	1249	case ColumnSizingSecondIteration:
1245	m_sizingState = RowSizingSecondIteration;	1250	m_sizingState = RowSizingSecondIteration;
Lines 1346-1351 void GridTrackSizingAlgorithm::run() a/Source/WebCore/rendering/GridTrackSizingAlgorithm.cpp_sec6
1346		1351
1347	// Step 3.	1352	// Step 3.
1348	m_strategy->maximizeTracks(tracks(m_direction), m_direction == ForColumns ? m_freeSpaceColumns : m_freeSpaceRows);	1353	m_strategy->maximizeTracks(tracks(m_direction), m_direction == ForColumns ? m_freeSpaceColumns : m_freeSpaceRows);
		1354	if (m_strategy->isComputingSizeContainment())
		1355	return;
1349		1356
1350	// Step 4.	1357	// Step 4.
1351	stretchFlexibleTracks(initialFreeSpace);	1358	stretchFlexibleTracks(initialFreeSpace);

Lines 315-321 LayoutRect RenderMenuList::controlClipRect(const LayoutPoint& additionalOffset) a/Source/WebCore/rendering/RenderMenuList.cpp_sec1
- a/Source/WebCore/rendering/RenderMenuList.cpp -1 / +2 lines
315		315
316	void RenderMenuList::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const	316	void RenderMenuList::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
317	{	317	{
318	maxLogicalWidth = std::max(m_optionsWidth, theme().minimumMenuListSize(style())) + m_innerBlock->paddingLeft() + m_innerBlock->paddingRight();	318	maxLogicalWidth = shouldApplySizeContainment() ? theme().minimumMenuListSize(style()) : std::max(m_optionsWidth, theme().minimumMenuListSize(style()));
		319	maxLogicalWidth += m_innerBlock->paddingLeft() + m_innerBlock->paddingRight();
319	if (!style().width().isPercentOrCalculated())	320	if (!style().width().isPercentOrCalculated())
320	minLogicalWidth = maxLogicalWidth;	321	minLogicalWidth = maxLogicalWidth;
321	}	322	}

Lines 730-735 public: a/Source/WebCore/rendering/RenderObject.h_sec1
- a/Source/WebCore/rendering/RenderObject.h +11 lines
730		730
731	virtual String debugDescription() const;	731	virtual String debugDescription() const;
732		732
		733	bool isAtomicInlineLevelBox() const
		734	{
		735	return style().isDisplayInlineType() && !(style().display() == DisplayType::Inline && !isReplaced());
		736	}
		737
		738	bool shouldApplySizeContainment() const
		739	{
		740	return style().contain().contains(Containment::Size) && (!isInline() \|\| isAtomicInlineLevelBox())
		741	&& !isRubyText() && (!isTablePart() \|\| isTableCaption()) && !isTable();
		742	}
		743
733	protected:	744	protected:
734	//////////////////////////////////////////	745	//////////////////////////////////////////
735	// Helper functions. Dangerous to use!	746	// Helper functions. Dangerous to use!

Lines 4777-4841 imported/w3c/web-platform-tests/css/css-contain/contain-paint-stacking-context-0 a/LayoutTests/TestExpectations_sec1
- a/LayoutTests/TestExpectations -59 / +25 lines
4777	imported/w3c/web-platform-tests/css/css-contain/contain-paint-stacking-context-001b.html [ ImageOnlyFailure ]	4777	imported/w3c/web-platform-tests/css/css-contain/contain-paint-stacking-context-001b.html [ ImageOnlyFailure ]
4778	imported/w3c/web-platform-tests/css/css-contain/contain-paint-table-001.html [ ImageOnlyFailure ]	4778	imported/w3c/web-platform-tests/css/css-contain/contain-paint-table-001.html [ ImageOnlyFailure ]
4779	imported/w3c/web-platform-tests/css/css-contain/contain-paint-table-002.html [ ImageOnlyFailure ]	4779	imported/w3c/web-platform-tests/css/css-contain/contain-paint-table-002.html [ ImageOnlyFailure ]
4780	imported/w3c/web-platform-tests/css/css-contain/contain-size-011.html [ ImageOnlyFailure ]
4781	imported/w3c/web-platform-tests/css/css-contain/contain-size-013.html [ ImageOnlyFailure ]
4782	imported/w3c/web-platform-tests/css/css-contain/contain-size-021.html [ ImageOnlyFailure ]
4783	imported/w3c/web-platform-tests/css/css-contain/contain-size-023.html [ ImageOnlyFailure ]
4784	imported/w3c/web-platform-tests/css/css-contain/contain-size-025.html [ ImageOnlyFailure ]
4785	imported/w3c/web-platform-tests/css/css-contain/contain-size-027.html [ ImageOnlyFailure ]
4786	imported/w3c/web-platform-tests/css/css-contain/contain-size-041.html [ ImageOnlyFailure ]
4787	imported/w3c/web-platform-tests/css/css-contain/contain-size-042.html [ ImageOnlyFailure ]
4788	imported/w3c/web-platform-tests/css/css-contain/contain-size-056.html [ ImageOnlyFailure ]
4789	imported/w3c/web-platform-tests/css/css-contain/contain-size-061.html [ ImageOnlyFailure ]
4790	imported/w3c/web-platform-tests/css/css-contain/contain-size-062.html [ ImageOnlyFailure ]
4791	imported/w3c/web-platform-tests/css/css-contain/contain-size-063.html [ ImageOnlyFailure ]
4792	imported/w3c/web-platform-tests/css/css-contain/contain-size-064.html [ ImageOnlyFailure ]
4793	imported/w3c/web-platform-tests/css/css-contain/contain-size-block-001.html [ ImageOnlyFailure ]
4794	imported/w3c/web-platform-tests/css/css-contain/contain-size-block-002.html [ ImageOnlyFailure ]
4795	imported/w3c/web-platform-tests/css/css-contain/contain-size-block-003.html [ ImageOnlyFailure ]
4796	imported/w3c/web-platform-tests/css/css-contain/contain-size-block-004.html [ ImageOnlyFailure ]
4797	imported/w3c/web-platform-tests/css/css-contain/contain-size-borders.html [ ImageOnlyFailure ]
4798	imported/w3c/web-platform-tests/css/css-contain/contain-size-breaks-001.html [ ImageOnlyFailure ]
4799	imported/w3c/web-platform-tests/css/css-contain/contain-size-button-001.html [ ImageOnlyFailure ]
4800	imported/w3c/web-platform-tests/css/css-contain/contain-size-button-002.html [ ImageOnlyFailure ]
4801	imported/w3c/web-platform-tests/css/css-contain/contain-size-fieldset-001.html [ ImageOnlyFailure ]
4802	imported/w3c/web-platform-tests/css/css-contain/contain-size-fieldset-002.html [ ImageOnlyFailure ]
4803	imported/w3c/web-platform-tests/css/css-contain/contain-size-fieldset-003.html [ ImageOnlyFailure ]
4804	imported/w3c/web-platform-tests/css/css-contain/contain-size-fieldset-004.html [ ImageOnlyFailure ]
4805	imported/w3c/web-platform-tests/css/css-contain/contain-size-flex-001.html [ ImageOnlyFailure ]
4806	imported/w3c/web-platform-tests/css/css-contain/contain-size-flexbox-001.html [ ImageOnlyFailure ]
4807	imported/w3c/web-platform-tests/css/css-contain/contain-size-grid-001.html [ ImageOnlyFailure ]
4808	imported/w3c/web-platform-tests/css/css-contain/contain-size-grid-002.html [ ImageOnlyFailure ]
4809	imported/w3c/web-platform-tests/css/css-contain/contain-size-grid-005.html [ ImageOnlyFailure ]
4810	imported/w3c/web-platform-tests/css/css-contain/contain-size-inline-block-001.html [ ImageOnlyFailure ]
4811	imported/w3c/web-platform-tests/css/css-contain/contain-size-inline-block-002.html [ ImageOnlyFailure ]
4812	imported/w3c/web-platform-tests/css/css-contain/contain-size-inline-block-003.html [ ImageOnlyFailure ]
4813	imported/w3c/web-platform-tests/css/css-contain/contain-size-inline-block-004.html [ ImageOnlyFailure ]
4814	imported/w3c/web-platform-tests/css/css-contain/contain-size-inline-flex-001.html [ ImageOnlyFailure ]
4815	imported/w3c/web-platform-tests/css/css-contain/contain-size-monolithic-001.html [ ImageOnlyFailure ]
4816	imported/w3c/web-platform-tests/css/css-contain/contain-size-monolithic-002.html [ ImageOnlyFailure ]
4817	imported/w3c/web-platform-tests/css/css-contain/contain-size-multicol-001.html [ ImageOnlyFailure ]
4818	imported/w3c/web-platform-tests/css/css-contain/contain-size-multicol-002.html [ ImageOnlyFailure ]
4819	imported/w3c/web-platform-tests/css/css-contain/contain-size-multicol-003.html [ ImageOnlyFailure ]
4820	imported/w3c/web-platform-tests/css/css-contain/contain-size-replaced-001.html [ ImageOnlyFailure ]
4821	imported/w3c/web-platform-tests/css/css-contain/contain-size-replaced-002.html [ ImageOnlyFailure ]
4822	imported/w3c/web-platform-tests/css/css-contain/contain-size-replaced-003a.html [ ImageOnlyFailure ]
4823	imported/w3c/web-platform-tests/css/css-contain/contain-size-replaced-003b.html [ ImageOnlyFailure ]
4824	imported/w3c/web-platform-tests/css/css-contain/contain-size-replaced-003c.html [ ImageOnlyFailure ]
4825	imported/w3c/web-platform-tests/css/css-contain/contain-size-replaced-004.html [ ImageOnlyFailure ]
4826	imported/w3c/web-platform-tests/css/css-contain/contain-size-replaced-005.html [ ImageOnlyFailure ]
4827	imported/w3c/web-platform-tests/css/css-contain/contain-size-replaced-006.html [ ImageOnlyFailure ]
4828	imported/w3c/web-platform-tests/css/css-contain/contain-size-scrollbars-001.html [ ImageOnlyFailure ]
4829	imported/w3c/web-platform-tests/css/css-contain/contain-size-scrollbars-002.html [ ImageOnlyFailure ]
4830	imported/w3c/web-platform-tests/css/css-contain/contain-size-scrollbars-003.html [ ImageOnlyFailure ]
4831	imported/w3c/web-platform-tests/css/css-contain/contain-size-select-001.html [ ImageOnlyFailure ]
4832	imported/w3c/web-platform-tests/css/css-contain/contain-size-select-002.html [ ImageOnlyFailure ]
4833	imported/w3c/web-platform-tests/css/css-contain/contain-size-select-elem-001.html [ ImageOnlyFailure ]
4834	imported/w3c/web-platform-tests/css/css-contain/contain-size-select-elem-002.html [ ImageOnlyFailure ]
4835	imported/w3c/web-platform-tests/css/css-contain/contain-size-select-elem-003.html [ ImageOnlyFailure ]
4836	imported/w3c/web-platform-tests/css/css-contain/contain-size-select-elem-004.html [ ImageOnlyFailure ]
4837	imported/w3c/web-platform-tests/css/css-contain/contain-size-select-elem-005.html [ ImageOnlyFailure ]
4838	imported/w3c/web-platform-tests/css/css-contain/contain-size-table-caption-001.html [ ImageOnlyFailure ]
4839	imported/w3c/web-platform-tests/css/css-contain/contain-strict-001.html [ ImageOnlyFailure ]	4780	imported/w3c/web-platform-tests/css/css-contain/contain-strict-001.html [ ImageOnlyFailure ]
4840	imported/w3c/web-platform-tests/css/css-contain/contain-strict-002.html [ ImageOnlyFailure ]	4781	imported/w3c/web-platform-tests/css/css-contain/contain-strict-002.html [ ImageOnlyFailure ]
4841	imported/w3c/web-platform-tests/css/css-contain/contain-strict-003.html [ ImageOnlyFailure ]	4782	imported/w3c/web-platform-tests/css/css-contain/contain-strict-003.html [ ImageOnlyFailure ]
Lines 4870-4875 imported/w3c/web-platform-tests/css/css-contain/quote-scoping-002.html [ ImageOn a/LayoutTests/TestExpectations_sec2
4870	imported/w3c/web-platform-tests/css/css-contain/quote-scoping-003.html [ ImageOnlyFailure ]	4811	imported/w3c/web-platform-tests/css/css-contain/quote-scoping-003.html [ ImageOnlyFailure ]
4871	imported/w3c/web-platform-tests/css/css-contain/quote-scoping-004.html [ ImageOnlyFailure ]	4812	imported/w3c/web-platform-tests/css/css-contain/quote-scoping-004.html [ ImageOnlyFailure ]
4872		4813
		4814	# Canvas doesn't get default aspect-ratio for width and height attributes.
		4815	webkit.org/b/217529 imported/w3c/web-platform-tests/css/css-flexbox/canvas-contain-size.html [ ImageOnlyFailure ]
		4816
		4817	# Content is painted on svg's padding area.
		4818	webkit.org/b/425868 imported/w3c/web-platform-tests/css/css-contain/contain-size-replaced-002.html [ ImageOnlyFailure ]
		4819
		4820	# Multicolumn does not paint the horizontal overflow area of a relative child.
		4821	webkit.org/b/41796 imported/w3c/web-platform-tests/css/css-contain/contain-size-monolithic-002.html [ ImageOnlyFailure ]
		4822
		4823	# Buttons with auto width and height has extra margins.
		4824	imported/w3c/web-platform-tests/css/css-contain/contain-size-button-001.html [ ImageOnlyFailure ]
		4825	imported/w3c/web-platform-tests/css/css-contain/contain-size-button-002.html [ ImageOnlyFailure ]
		4826
		4827	# Scrollbar displays are different.
		4828	imported/w3c/web-platform-tests/css/css-contain/contain-size-block-003.html [ ImageOnlyFailure ]
		4829	imported/w3c/web-platform-tests/css/css-contain/contain-size-inline-block-003.html [ ImageOnlyFailure ]
		4830
		4831	# Select with empty content always has root linebox, so the heights are different.
		4832	imported/w3c/web-platform-tests/css/css-contain/contain-size-select-001.html [ ImageOnlyFailure ]
		4833	imported/w3c/web-platform-tests/css/css-contain/contain-size-select-002.html [ ImageOnlyFailure ]
		4834
		4835	# CSS property color is not working in select elements.
		4836	imported/w3c/web-platform-tests/css/css-contain/contain-size-select-elem-001.html [ ImageOnlyFailure ]
		4837	imported/w3c/web-platform-tests/css/css-contain/contain-size-select-elem-002.html [ ImageOnlyFailure ]
		4838
4873	# @counter-style ref tests that currently fail	4839	# @counter-style ref tests that currently fail
4874	imported/w3c/web-platform-tests/css/css-counter-styles/armenian/css3-counter-styles-006.html [ ImageOnlyFailure ]	4840	imported/w3c/web-platform-tests/css/css-counter-styles/armenian/css3-counter-styles-006.html [ ImageOnlyFailure ]
4875	imported/w3c/web-platform-tests/css/css-counter-styles/armenian/css3-counter-styles-007.html [ ImageOnlyFailure ]	4841	imported/w3c/web-platform-tests/css/css-counter-styles/armenian/css3-counter-styles-007.html [ ImageOnlyFailure ]

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +94 lines
		1	2021-04-12 Cathie Chen <cathiechen@igalia.com>
		2
		3	[CSS contain] Support contain:size
		4	https://bugs.webkit.org/show_bug.cgi?id=223570
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	This patch brings initial support of CSS contain:size according to [1],
		9	It adds shouldApplySizeContainment to indicate whether it is a size containment box.
		10	The intrinsic sizes of size containment box are determined as if it had no content.
		11	So cooperating with the layout steps:
		12	- Calculate logical width: Size containment boxes skip handling children while computing minLogicalWidth
		13	and maxLogicalWidth in computeIntrinsicLogicalWidths.
		14	- Layout children.
		15	- Calculate logical height: At the beginning, size containment boxes reset logical height to the empty content height
		16	if it is not renderGrid.
		17	We also need to calculate the sizes according to the layout algorithms.
		18	- Grid layout:
		19	To calculate the minLogicalWidth and maxLogicalWidth for indefinite size RenderGrid.
		20	The widths are calculated by GridTrackSizingAlgorithm: m_minContentSize and m_maxContentSize which are the sum of
		21	m_baseSize/m_growthLimit of all GridTracks. The size containment RenderGrid skips handling content in resolveIntrinsicTrackSizes
		22	and the m_maxContentSize will be the sum of m_baseSize. The logical height is same to width, but after calculating
		23	RenderGrid's logical height, it needs to calculate the track sizes again, to make sure that they are distributed properly.
		24	We use computeTrackSizesForDefiniteSize(ForRows, trackBasedLogicalHeight) to recalculate it.
		25	- MultiColumn layout:
		26	According to the specification, size containment boxes should be monolithic, so we need to extend column height
		27	for overflow and positioned size containment box. m_spaceShortageForSizeContainment is added to indicate the shortage space
		28	that need to balance the column heights. adjustSizeContainmentChildForPagination will calculate the shortage.
		29
		30	[1] https://www.w3.org/TR/css-contain-1/#containment-size
		31
		32	* rendering/GridTrackSizingAlgorithm.cpp: Add isComputingSizeContainment to indicate if it is calculating sizes
		33	for indefinite size RenderGrid which size containment.
		34	(WebCore::GridTrackSizingAlgorithm::computeGridContainerIntrinsicSizes):
		35	It might skip resolveIntrinsicTrackSizes if isComputingSizeContainment, so growthLimit might be undefined,
		36	if so, use track.baseSize() instead.
		37	(WebCore::GridTrackSizingAlgorithm::resolveIntrinsicTrackSizes): Skip resolve the content if isComputingSizeContainment.
		38	(WebCore::GridTrackSizingAlgorithm::advanceNextState):
		39	(WebCore::GridTrackSizingAlgorithm::run): Do not stretch the track sizes if isComputingSizeContainment.
		40	* rendering/GridTrackSizingAlgorithm.h:
		41	* rendering/RenderBlock.cpp:
		42	(WebCore::RenderBlock::layoutPositionedObject): Calculate m_spaceShortageForSizeContainment for position size containment
		43	in adjustSizeContainmentChildForPagination.
		44	(WebCore::RenderBlock::computeIntrinsicLogicalWidths const): Skip computeBlockPreferredLogicalWidths if shouldApplySizeContainment.
		45	* rendering/RenderBlockFlow.cpp:
		46	(WebCore::RenderBlockFlow::computeIntrinsicLogicalWidths const): Skip handling the children for size containment box.
		47	(WebCore::RenderBlockFlow::adjustBlockChildForPagination): Calculate m_spaceShortageForSizeContainment for child.
		48	(WebCore::RenderBlockFlow::adjustSizeContainmentChildForPagination): m_spaceShortageForSizeContainment = childOverflowHeight - remainingLogicalHeight.
		49	* rendering/RenderBlockFlow.h:
		50	* rendering/RenderBox.cpp:
		51	(WebCore::RenderBox::updateLogicalHeight): Reset the logical height to empty content height for size containment box.
		52	(WebCore::RenderBox::isUnsplittableForPagination const): Size containment box is unsplittable.
		53	* rendering/RenderDeprecatedFlexibleBox.cpp:
		54	(WebCore::RenderDeprecatedFlexibleBox::computeIntrinsicLogicalWidths const): Ditto.
		55	* rendering/RenderFileUploadControl.cpp:
		56	(WebCore::RenderFileUploadControl::computeIntrinsicLogicalWidths const): Ditto.
		57	* rendering/RenderFlexibleBox.cpp:
		58	(WebCore::RenderFlexibleBox::computeIntrinsicLogicalWidths const): Ditto.
		59	* rendering/RenderFragmentedFlow.h:
		60	* rendering/RenderGrid.cpp:
		61	(WebCore::RenderGrid::layoutBlock): If it is size containment with infiniteSize, using trackBasedLogicalHeight
		62	to compute track sizes again to make sure the height is distributed properly.
		63	(WebCore::RenderGrid::computeAutoRepeatTracksCount const): Because size containment's content was empty,
		64	the repeat tracks count is always 0.
65	* rendering/RenderImage.cpp:
66	(WebCore::RenderImage::computeIntrinsicRatioInformation const): This is handled in RenderReplaced::computeIntrinsicRatioInformation instead.
67	* rendering/RenderListBox.cpp:
68	(WebCore::RenderListBox::computeIntrinsicLogicalWidths const): The widths of size containment box are optionsSpacingHorizontal.
69	* rendering/RenderMenuList.cpp:
70	(RenderMenuList::computeIntrinsicLogicalWidths const): The widths of size containment box are theme.minimumMenuListSize.
71	* rendering/RenderMultiColumnFlow.cpp:
72	(WebCore::RenderMultiColumnFlow::updateSpaceShortageForSizeContainment): Set m_spaceShortageForSizeContainment.
73	* rendering/RenderMultiColumnFlow.h:
74	* rendering/RenderMultiColumnSet.cpp:
75	(WebCore::RenderMultiColumnSet::RenderMultiColumnSet):
76	(WebCore::RenderMultiColumnSet::calculateBalancedHeight const): Add m_spaceShortageForSizeContainment to the column height.
77	(WebCore::RenderMultiColumnSet::prepareForLayout): Reset m_spaceShortageForSizeContainment.
78	* rendering/RenderMultiColumnSet.h:
79	* rendering/RenderObject.h:
80	(WebCore::RenderObject::isAtomicInlineLevelBox const):
81	(WebCore::RenderObject::shouldApplySizeContainment const): Check if this is a size containment box.
82	* rendering/RenderReplaced.cpp:
83	(WebCore::RenderReplaced::computeAspectRatioInformationForRenderBox const):
84	(WebCore::RenderReplaced::computeIntrinsicRatioInformation const): Use the empty intrinsicSize.
85	* rendering/RenderReplaced.h: The intrinsicSize of size containment is (0, 0).
86	* rendering/RenderSlider.cpp:
87	(WebCore::RenderSlider::computeIntrinsicLogicalWidths const): Ditto.
88	* rendering/RenderTextControl.cpp:
89	(WebCore::RenderTextControl::computeIntrinsicLogicalWidths const): Ditto.
90	* rendering/RenderVideo.cpp:
91	(WebCore::RenderVideo::calculateIntrinsicSize): Ditto.
92	* rendering/svg/RenderSVGRoot.cpp:
93	(WebCore::RenderSVGRoot::computeIntrinsicRatioInformation const): Handled in RenderReplaced::computeIntrinsicRatioInformation instead.
94
1	2021-04-12 Rob Buis <rbuis@igalia.com>	95	2021-04-12 Rob Buis <rbuis@igalia.com>
2		96
3	Clamp overridingContentLogicalWidth/Height to zero	97	Clamp overridingContentLogicalWidth/Height to zero

Lines 187-212 void RenderDeprecatedFlexibleBox::styleWillChange(StyleDifference diff, const Re a/Source/WebCore/rendering/RenderDeprecatedFlexibleBox.cpp_sec1
- a/Source/WebCore/rendering/RenderDeprecatedFlexibleBox.cpp -17 / +19 lines
187		187
188	void RenderDeprecatedFlexibleBox::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const	188	void RenderDeprecatedFlexibleBox::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
189	{	189	{
190	if (hasMultipleLines() \|\| isVertical()) {	190	if (!shouldApplySizeContainment()) {
191	for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {	191	if (hasMultipleLines() \|\| isVertical()) {
192	if (childDoesNotAffectWidthOrFlexing(child))	192	for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
193	continue;	193	if (childDoesNotAffectWidthOrFlexing(child))
		194	continue;
194		195
195	LayoutUnit margin = marginWidthForChild(child);	196	LayoutUnit margin = marginWidthForChild(child);
196	LayoutUnit width = child->minPreferredLogicalWidth() + margin;	197	LayoutUnit width = child->minPreferredLogicalWidth() + margin;
197	minLogicalWidth = std::max(width, minLogicalWidth);	198	minLogicalWidth = std::max(width, minLogicalWidth);
198		199
199	width = child->maxPreferredLogicalWidth() + margin;	200	width = child->maxPreferredLogicalWidth() + margin;
200	maxLogicalWidth = std::max(width, maxLogicalWidth);	201	maxLogicalWidth = std::max(width, maxLogicalWidth);
201	}	202	}
202	} else {	203	} else {
203	for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {	204	for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
204	if (childDoesNotAffectWidthOrFlexing(child))	205	if (childDoesNotAffectWidthOrFlexing(child))
205	continue;	206	continue;
206		207
207	LayoutUnit margin = marginWidthForChild(child);	208	LayoutUnit margin = marginWidthForChild(child);
208	minLogicalWidth += child->minPreferredLogicalWidth() + margin;	209	minLogicalWidth += child->minPreferredLogicalWidth() + margin;
209	maxLogicalWidth += child->maxPreferredLogicalWidth() + margin;	210	maxLogicalWidth += child->maxPreferredLogicalWidth() + margin;
		211	}
210	}	212	}
211	}	213	}
212		214

Lines 83-142 const char* RenderFlexibleBox::renderName() const a/Source/WebCore/rendering/RenderFlexibleBox.cpp_sec1
- a/Source/WebCore/rendering/RenderFlexibleBox.cpp -50 / +52 lines
83		83
84	void RenderFlexibleBox::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const	84	void RenderFlexibleBox::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
85	{	85	{
86	LayoutUnit childMinWidth;	86	if (!shouldApplySizeContainment()) {
87	LayoutUnit childMaxWidth;	87	LayoutUnit childMinWidth;
88	bool hadExcludedChildren = computePreferredWidthsForExcludedChildren(childMinWidth, childMaxWidth);	88	LayoutUnit childMaxWidth;
89		89	bool hadExcludedChildren = computePreferredWidthsForExcludedChildren(childMinWidth, childMaxWidth);
90	// FIXME: We're ignoring flex-basis here and we shouldn't. We can't start	90
91	// honoring it though until the flex shorthand stops setting it to 0. See	91	// FIXME: We're ignoring flex-basis here and we shouldn't. We can't start
92	// https://bugs.webkit.org/show_bug.cgi?id=116117 and	92	// honoring it though until the flex shorthand stops setting it to 0. See
93	// https://crbug.com/240765.	93	// https://bugs.webkit.org/show_bug.cgi?id=116117 and
94	size_t numItemsWithNormalLayout = 0;	94	// https://crbug.com/240765.
95	for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {	95	size_t numItemsWithNormalLayout = 0;
96	if (child->isOutOfFlowPositioned() \|\| child->isExcludedFromNormalLayout())	96	for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
97	continue;	97	if (child->isOutOfFlowPositioned() \|\| child->isExcludedFromNormalLayout())
98	++numItemsWithNormalLayout;	98	continue;
		99	++numItemsWithNormalLayout;
99		100
100	LayoutUnit margin = marginIntrinsicLogicalWidthForChild(*child);	101	LayoutUnit margin = marginIntrinsicLogicalWidthForChild(*child);
101		102
102	LayoutUnit minPreferredLogicalWidth;	103	LayoutUnit minPreferredLogicalWidth;
103	LayoutUnit maxPreferredLogicalWidth;	104	LayoutUnit maxPreferredLogicalWidth;
104	computeChildPreferredLogicalWidths(*child, minPreferredLogicalWidth, maxPreferredLogicalWidth);	105	computeChildPreferredLogicalWidths(*child, minPreferredLogicalWidth, maxPreferredLogicalWidth);
105		106
106	minPreferredLogicalWidth += margin;	107	minPreferredLogicalWidth += margin;
107	maxPreferredLogicalWidth += margin;	108	maxPreferredLogicalWidth += margin;
108		109
109	if (!isColumnFlow()) {	110	if (!isColumnFlow()) {
110	maxLogicalWidth += maxPreferredLogicalWidth;	111	maxLogicalWidth += maxPreferredLogicalWidth;
111	if (isMultiline()) {	112	if (isMultiline()) {
112	// For multiline, the min preferred width is if you put a break between	113	// For multiline, the min preferred width is if you put a break between
113	// each item.	114	// each item.
114	minLogicalWidth = std::max(minLogicalWidth, minPreferredLogicalWidth);	115	minLogicalWidth = std::max(minLogicalWidth, minPreferredLogicalWidth);
115	} else	116	} else
116	minLogicalWidth += minPreferredLogicalWidth;	117	minLogicalWidth += minPreferredLogicalWidth;
117	} else {	118	} else {
118	minLogicalWidth = std::max(minPreferredLogicalWidth, minLogicalWidth);	119	minLogicalWidth = std::max(minPreferredLogicalWidth, minLogicalWidth);
119	maxLogicalWidth = std::max(maxPreferredLogicalWidth, maxLogicalWidth);	120	maxLogicalWidth = std::max(maxPreferredLogicalWidth, maxLogicalWidth);
		121	}
120	}	122	}
121	}
122		123
123	if (!isColumnFlow() && numItemsWithNormalLayout > 1) {	124	if (!isColumnFlow() && numItemsWithNormalLayout > 1) {
124	LayoutUnit inlineGapSize = (numItemsWithNormalLayout - 1) * computeGap(GapType::BetweenItems);	125	LayoutUnit inlineGapSize = (numItemsWithNormalLayout - 1) * computeGap(GapType::BetweenItems);
125	maxLogicalWidth += inlineGapSize;	126	maxLogicalWidth += inlineGapSize;
126	if (!isMultiline())	127	if (!isMultiline())
127	minLogicalWidth += inlineGapSize;	128	minLogicalWidth += inlineGapSize;
128	}	129	}
129		130
130	maxLogicalWidth = std::max(minLogicalWidth, maxLogicalWidth);	131	maxLogicalWidth = std::max(minLogicalWidth, maxLogicalWidth);
131		132
132	// Due to negative margins, it is possible that we calculated a negative	133	// Due to negative margins, it is possible that we calculated a negative
133	// intrinsic width. Make sure that we never return a negative width.	134	// intrinsic width. Make sure that we never return a negative width.
134	minLogicalWidth = std::max(0_lu, minLogicalWidth);	135	minLogicalWidth = std::max(0_lu, minLogicalWidth);
135	maxLogicalWidth = std::max(0_lu, maxLogicalWidth);	136	maxLogicalWidth = std::max(0_lu, maxLogicalWidth);
136		137
137	if (hadExcludedChildren) {	138	if (hadExcludedChildren) {
138	minLogicalWidth = std::max(minLogicalWidth, childMinWidth);	139	minLogicalWidth = std::max(minLogicalWidth, childMinWidth);
139	maxLogicalWidth = std::max(maxLogicalWidth, childMaxWidth);	140	maxLogicalWidth = std::max(maxLogicalWidth, childMaxWidth);
		141	}
140	}	142	}
141		143
142	LayoutUnit scrollbarWidth(scrollbarLogicalWidth());	144	LayoutUnit scrollbarWidth(scrollbarLogicalWidth());

Lines 50-55 RenderMultiColumnSet::RenderMultiColumnSet(RenderFragmentedFlow& fragmentedFlow, a/Source/WebCore/rendering/RenderMultiColumnSet.cpp_sec1
- a/Source/WebCore/rendering/RenderMultiColumnSet.cpp -4 / +9 lines
50	, m_maxColumnHeight(RenderFragmentedFlow::maxLogicalHeight())	50	, m_maxColumnHeight(RenderFragmentedFlow::maxLogicalHeight())
51	, m_minSpaceShortage(RenderFragmentedFlow::maxLogicalHeight())	51	, m_minSpaceShortage(RenderFragmentedFlow::maxLogicalHeight())
52	, m_minimumColumnHeight(0)	52	, m_minimumColumnHeight(0)
		53	, m_spaceShortageForSizeContainment(0)
53	{	54	{
54	}	55	}
55		56
Lines 235-249 LayoutUnit RenderMultiColumnSet::calculateBalancedHeight(bool initial) const a/Source/WebCore/rendering/RenderMultiColumnSet.cpp_sec2
235	return std::max<LayoutUnit>(m_contentRuns[index].columnLogicalHeight(startOffset), m_minimumColumnHeight);	236	return std::max<LayoutUnit>(m_contentRuns[index].columnLogicalHeight(startOffset), m_minimumColumnHeight);
236	}	237	}
237		238
		239	LayoutUnit sizeContainmentShortage = std::max<LayoutUnit>(LayoutUnit(), m_spaceShortageForSizeContainment);
238	if (columnCount() <= computedColumnCount()) {	240	if (columnCount() <= computedColumnCount()) {
239	// With the current column height, the content fits without creating overflowing columns. We're done.	241	// With the current column height, the content fits without creating overflowing columns. We're done.
240	return m_computedColumnHeight;	242	return m_computedColumnHeight + sizeContainmentShortage;
241	}	243	}
242		244
243	if (forcedBreaksCount() >= computedColumnCount()) {	245	if (forcedBreaksCount() >= computedColumnCount()) {
244	// Too many forced breaks to allow any implicit breaks. Initial balancing should already	246	// Too many forced breaks to allow any implicit breaks. Initial balancing should already
245	// have set a good height. There's nothing more we should do.	247	// have set a good height. There's nothing more we should do.
246	return m_computedColumnHeight;	248	return m_computedColumnHeight + sizeContainmentShortage;
247	}	249	}
248		250
249	// If the initial guessed column height wasn't enough, stretch it now. Stretch by the lowest	251	// If the initial guessed column height wasn't enough, stretch it now. Stretch by the lowest
Lines 252-260 LayoutUnit RenderMultiColumnSet::calculateBalancedHeight(bool initial) const a/Source/WebCore/rendering/RenderMultiColumnSet.cpp_sec3
252	ASSERT(m_minSpaceShortage > 0); // We should never _shrink_ the height!	254	ASSERT(m_minSpaceShortage > 0); // We should never _shrink_ the height!
253	// ASSERT(m_minSpaceShortage != RenderFragmentedFlow::maxLogicalHeight()); // If this happens, we probably have a bug.	255	// ASSERT(m_minSpaceShortage != RenderFragmentedFlow::maxLogicalHeight()); // If this happens, we probably have a bug.
254	if (m_minSpaceShortage == RenderFragmentedFlow::maxLogicalHeight())	256	if (m_minSpaceShortage == RenderFragmentedFlow::maxLogicalHeight())
255	return m_computedColumnHeight; // So bail out rather than looping infinitely.	257	return m_computedColumnHeight + sizeContainmentShortage; // So bail out rather than looping infinitely.
256		258
257	return m_computedColumnHeight + m_minSpaceShortage;	259	auto toAdd = std::max<LayoutUnit>(sizeContainmentShortage, m_minSpaceShortage);
		260	return m_computedColumnHeight + toAdd;
258	}	261	}
259		262
260	void RenderMultiColumnSet::clearForcedBreaks()	263	void RenderMultiColumnSet::clearForcedBreaks()
Lines 365-370 void RenderMultiColumnSet::prepareForLayout(bool initial) a/Source/WebCore/rendering/RenderMultiColumnSet.cpp_sec4
365	// Nuke previously stored minimum column height. Contents may have changed for all we know.	368	// Nuke previously stored minimum column height. Contents may have changed for all we know.
366	m_minimumColumnHeight = 0;	369	m_minimumColumnHeight = 0;
367		370
		371	m_spaceShortageForSizeContainment = 0;
		372
368	// Start with "infinite" flow thread portion height until height is known.	373	// Start with "infinite" flow thread portion height until height is known.
369	setLogicalBottomInFragmentedFlow(RenderFragmentedFlow::maxLogicalHeight());	374	setLogicalBottomInFragmentedFlow(RenderFragmentedFlow::maxLogicalHeight());
370		375

Lines 83-88 public: a/Source/WebCore/rendering/RenderMultiColumnSet.h_sec1
- a/Source/WebCore/rendering/RenderMultiColumnSet.h +10 lines
83	void updateMinimumColumnHeight(LayoutUnit height) { m_minimumColumnHeight = std::max(height, m_minimumColumnHeight); }	83	void updateMinimumColumnHeight(LayoutUnit height) { m_minimumColumnHeight = std::max(height, m_minimumColumnHeight); }
84	LayoutUnit minimumColumnHeight() const { return m_minimumColumnHeight; }	84	LayoutUnit minimumColumnHeight() const { return m_minimumColumnHeight; }
85		85
		86	void updateSpaceShortageForSizeContainment(LayoutUnit shortage)
		87	{
		88	if (m_spaceShortageForSizeContainment <= 0) {
		89	m_spaceShortageForSizeContainment = shortage;
		90	return;
		91	}
		92	m_spaceShortageForSizeContainment = std::min(shortage, m_spaceShortageForSizeContainment);
		93	}
		94
86	unsigned forcedBreaksCount() const { return m_contentRuns.size(); }	95	unsigned forcedBreaksCount() const { return m_contentRuns.size(); }
87	void clearForcedBreaks();	96	void clearForcedBreaks();
88	void addForcedBreak(LayoutUnit offsetFromFirstPage);	97	void addForcedBreak(LayoutUnit offsetFromFirstPage);
Lines 198-203 private: a/Source/WebCore/rendering/RenderMultiColumnSet.h_sec2
198	LayoutUnit m_maxColumnHeight; // Maximum column height allowed.	207	LayoutUnit m_maxColumnHeight; // Maximum column height allowed.
199	LayoutUnit m_minSpaceShortage; // The smallest amout of space shortage that caused a column break.	208	LayoutUnit m_minSpaceShortage; // The smallest amout of space shortage that caused a column break.
200	LayoutUnit m_minimumColumnHeight;	209	LayoutUnit m_minimumColumnHeight;
		210	LayoutUnit m_spaceShortageForSizeContainment; // The shortage space that keeps size containment monolithic.
201		211
202	// A run of content without explicit (forced) breaks; i.e. a flow thread portion between two	212	// A run of content without explicit (forced) breaks; i.e. a flow thread portion between two
203	// explicit breaks, between flow thread start and an explicit break, between an explicit break	213	// explicit breaks, between flow thread start and an explicit break, between an explicit break

Lines 1-3 a/LayoutTests/ChangeLog_sec1
- a/LayoutTests/ChangeLog +12 lines
		1	2021-04-12 Cathie Chen <cathiechen@igalia.com>
		2
		3	[CSS contain] Support contain:size
		4	https://bugs.webkit.org/show_bug.cgi?id=223570
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Update the test result for size containment. Added explanations for size containment tests
		9	that depended on other features.
		10
		11	* TestExpectations:
		12
1	2021-04-12 Rob Buis <rbuis@igalia.com>	13	2021-04-12 Rob Buis <rbuis@igalia.com>
2		14
3	Clamp overridingContentLogicalWidth/Height to zero	15	Clamp overridingContentLogicalWidth/Height to zero

Lines 1-3 a/LayoutTests/imported/w3c/ChangeLog_sec1
- a/LayoutTests/imported/w3c/ChangeLog +12 lines
		1	2021-04-12 Cathie Chen <cathiechen@igalia.com>
		2
		3	[CSS contain] Support contain:size
		4	https://bugs.webkit.org/show_bug.cgi?id=223570
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* web-platform-tests/css/css-contain/contain-size-grid-003-expected.txt:
		9	* web-platform-tests/css/css-contain/contain-size-grid-004-expected.txt:
		10	* web-platform-tests/css/css-contain/contain-size-multicol-as-flex-item-expected.txt:
		11	* web-platform-tests/css/css-flexbox/flex-item-contains-strict-expected.txt:
		12
1	2021-04-11 Sam Weinig <weinig@apple.com>	13	2021-04-11 Sam Weinig <weinig@apple.com>
2		14
3	Reduce compile time and binary size cost of enabling proper CSSStyleDeclaration property access behavior	15	Reduce compile time and binary size cost of enabling proper CSSStyleDeclaration property access behavior

Lines 36-54 PASS .grid 34 a/LayoutTests/imported/w3c/web-platform-tests/css/css-contain/contain-size-grid-003-expected.txt_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/css/css-contain/contain-size-grid-003-expected.txt -13 / +2 lines
36	PASS .grid 35	36	PASS .grid 35
37	PASS .grid 36	37	PASS .grid 36
38	PASS .grid 37	38	PASS .grid 37
39	FAIL .grid 38 assert_equals:	39	PASS .grid 38
40	<div class="grid" style="grid: repeat(auto-fit, 75px) / repeat(auto-fit, 100px);" data-expected-width="0" data-expected-height="0">	40	PASS .grid 39
41	<div></div>
42	</div>
43	width expected 0 but got 100
44	FAIL .grid 39 assert_equals:
45	<div class="grid" style="grid: auto 50px / 100px auto;" data-expected-width="100" data-expected-height="50">
46	<div data-expected-width="100" data-expected-height="10" data-offset-x="0" data-offset-y="0">X</div>
47	<div data-expected-width="40" data-expected-height="10" data-offset-x="100" data-offset-y="0">XX</div>
48	<div data-expected-width="100" data-expected-height="50" data-offset-x="0" data-offset-y="10">XXX</div>
49	<div data-expected-width="40" data-expected-height="50" data-offset-x="100" data-offset-y="10">XXXX</div>
50	</div>
51	width expected 100 but got 140
52		41
53	X	42	X
54	XX	43	XX

Lines 1-38 a/LayoutTests/imported/w3c/web-platform-tests/css/css-contain/contain-size-grid-004-expected.txt_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/css/css-contain/contain-size-grid-004-expected.txt -70 / +14 lines
1		1
2	PASS .grid 1	2	PASS .grid 1
3	FAIL .grid 2 assert_equals:	3	PASS .grid 2
4	<div class="grid percent min-content" data-expected-height="0" data-expected-width="0">
5	<div data-expected-height="0" data-expected-width="0">XXXX</div>
6	</div>
7	width expected 0 but got 300
8	PASS .grid 3	4	PASS .grid 3
9	FAIL .grid 4 assert_equals:	5	PASS .grid 4
10	<div class="grid percent max-content" data-expected-height="0" data-expected-width="0">
11	<div data-expected-height="0" data-expected-width="0">XXXX</div>
12	</div>
13	width expected 0 but got 300
14	PASS .grid 5	6	PASS .grid 5
15	PASS .grid 6	7	PASS .grid 6
16	PASS .grid 7	8	PASS .grid 7
17	FAIL .grid 8 assert_equals:	9	PASS .grid 8
18	<div class="grid calc min-content" data-expected-height="0" data-expected-width="0">
19	<div data-expected-height="100" data-expected-width="100">XXXX</div>
20	</div>
21	width expected 0 but got 300
22	PASS .grid 9	10	PASS .grid 9
23	FAIL .grid 10 assert_equals:	11	PASS .grid 10
24	<div class="grid calc max-content" data-expected-height="0" data-expected-width="0">
25	<div data-expected-height="100" data-expected-width="100">XXXX</div>
26	</div>
27	width expected 0 but got 300
28	PASS .grid 11	12	PASS .grid 11
29	PASS .grid 12	13	PASS .grid 12
30	PASS .grid 13	14	PASS .grid 13
31	FAIL .grid 14 assert_equals:	15	PASS .grid 14
32	<div class="grid minmax-percent-fixed min-content" data-expected-height="100" data-expected-width="0">
33	<div data-expected-height="100" data-expected-width="0">XXXX</div>
34	</div>
35	width expected 0 but got 100
36	PASS .grid 15	16	PASS .grid 15
37	PASS .grid 16	17	PASS .grid 16
38	PASS .grid 17	18	PASS .grid 17
Lines 40-106 PASS .grid 18 a/LayoutTests/imported/w3c/web-platform-tests/css/css-contain/contain-size-grid-004-expected.txt_sec2
40	PASS .grid 19	20	PASS .grid 19
41	PASS .grid 20	21	PASS .grid 20
42	PASS .grid 21	22	PASS .grid 21
43	FAIL .grid 22 assert_equals:	23	PASS .grid 22
44	<div class="grid minmax-fixed-percent max-content" data-expected-height="100" data-expected-width="100">
45	<div data-expected-height="100" data-expected-width="100">XXXX</div>
46	</div>
47	width expected 100 but got 300
48	PASS .grid 23	24	PASS .grid 23
49	PASS .grid 24	25	PASS .grid 24
50	PASS .grid 25	26	PASS .grid 25
51	FAIL .grid 26 assert_equals:	27	PASS .grid 26
52	<div class="grid minmax-percent-flex min-content" data-expected-height="0" data-expected-width="0">
53	<div data-expected-height="0" data-expected-width="0">XXXX</div>
54	</div>
55	width expected 0 but got 300
56	PASS .grid 27	28	PASS .grid 27
57	FAIL .grid 28 assert_equals:	29	PASS .grid 28
58	<div class="grid minmax-percent-flex max-content" data-expected-height="0" data-expected-width="0">
59	<div data-expected-height="0" data-expected-width="0">XXXX</div>
60	</div>
61	width expected 0 but got 300
62	PASS .grid 29	30	PASS .grid 29
63	PASS .grid 30	31	PASS .grid 30
64	PASS .grid 31	32	PASS .grid 31
65	FAIL .grid 32 assert_equals:	33	PASS .grid 32
66	<div class="grid minmax-intrinsic-percent min-content" data-expected-height="0" data-expected-width="0">
67	<div data-expected-height="75" data-expected-width="300">XXXX</div>
68	</div>
69	width expected 0 but got 300
70	PASS .grid 33	34	PASS .grid 33
71	FAIL .grid 34 assert_equals:	35	PASS .grid 34
72	<div class="grid minmax-intrinsic-percent max-content" data-expected-height="0" data-expected-width="0">
73	<div data-expected-height="75" data-expected-width="300">XXXX</div>
74	</div>
75	width expected 0 but got 300
76	PASS .grid 35	36	PASS .grid 35
77	PASS .grid 36	37	PASS .grid 36
78	PASS .grid 37	38	PASS .grid 37
79	FAIL .grid 38 assert_equals:	39	PASS .grid 38
80	<div class="grid minmax-percent-intrinsic min-content" data-expected-height="0" data-expected-width="0">
81	<div data-expected-height="0" data-expected-width="0">XXXX</div>
82	</div>
83	width expected 0 but got 300
84	PASS .grid 39	40	PASS .grid 39
85	FAIL .grid 40 assert_equals:	41	PASS .grid 40
86	<div class="grid minmax-percent-intrinsic max-content" data-expected-height="0" data-expected-width="0">
87	<div data-expected-height="0" data-expected-width="0">XXXX</div>
88	</div>
89	width expected 0 but got 300
90	PASS .grid 41	42	PASS .grid 41
91	PASS .grid 42	43	PASS .grid 42
92	PASS .grid 43	44	PASS .grid 43
93	FAIL .grid 44 assert_equals:	45	PASS .grid 44
94	<div class="grid fit-content min-content" data-expected-height="0" data-expected-width="0">
95	<div data-expected-height="75" data-expected-width="300">XXXX</div>
96	</div>
97	width expected 0 but got 300
98	PASS .grid 45	46	PASS .grid 45
99	FAIL .grid 46 assert_equals:	47	PASS .grid 46
100	<div class="grid fit-content max-content" data-expected-height="0" data-expected-width="0">
101	<div data-expected-height="75" data-expected-width="300">XXXX</div>
102	</div>
103	width expected 0 but got 300
104	PASS .grid 47	48	PASS .grid 47
105	PASS .grid 48	49	PASS .grid 48
106	XXXX	50	XXXX

Lines 1-11 a/LayoutTests/imported/w3c/web-platform-tests/css/css-contain/contain-size-multicol-as-flex-item-expected.txt_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/css/css-contain/contain-size-multicol-as-flex-item-expected.txt -7 / +1 lines
1	There should be a green square below.	1	There should be a green square below.
2		2
3		3
4	FAIL #flex 1 assert_equals:	4	PASS #flex 1
5	<div id="flex">
6	<div id="multicol" data-expected-width="100" data-expected-height="100">
7	<div style="width:1000px; height:1px;"></div>
8	</div>
9	</div>
10	width expected 100 but got 784
11		5

Lines 17-44 Column a/LayoutTests/imported/w3c/web-platform-tests/css/css-flexbox/flex-item-contains-strict-expected.txt_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/css/css-flexbox/flex-item-contains-strict-expected.txt -20 / +4 lines
17		17
18	Row	18	Row
19		19
20	FAIL .inline-flex 1 assert_equals:	20	PASS .inline-flex 1
21	<div class="inline-flex" style="display: inline-flex; flex-direction: column;" data-expected-width="0" data-expected-height="0">	21	PASS .inline-flex 2
22	<div style="contain: strict;" data-expected-width="0" data-expected-height="0">Column</div>
23	</div>
24	width expected 0 but got 52
25	FAIL .inline-flex 2 assert_equals:
26	<div class="inline-flex" data-expected-width="0" data-expected-height="0">
27	<div style="contain: strict;" data-expected-width="0" data-expected-height="0">Row</div>
28	</div>
29	width expected 0 but got 30
30	PASS .inline-flex 3	22	PASS .inline-flex 3
31	PASS .inline-flex 4	23	PASS .inline-flex 4
32	FAIL .inline-flex 5 assert_equals:	24	PASS .inline-flex 5
33	<div class="inline-flex" style="flex-direction: column; align-items: flex-start;" data-expected-width="0" data-expected-height="0">	25	PASS .inline-flex 6
34	<div style="contain: strict;" data-expected-width="0" data-expected-height="0">Column</div>
35	</div>
36	width expected 0 but got 52
37	FAIL .inline-flex 6 assert_equals:
38	<div class="inline-flex" style="align-items: flex-start;" data-expected-width="0" data-expected-height="0">
39	<div style="contain: strict;" data-expected-width="0" data-expected-height="0">Row</div>
40	</div>
41	width expected 0 but got 30
42	PASS .inline-flex 7	26	PASS .inline-flex 7
43	PASS .inline-flex 8	27	PASS .inline-flex 8
44		28