Attachment #358430 for bug #193168

View Details Raw Unified Return to Bug 193168



2019-01-04  Zalan Bujtas  <zalan@apple.com>

        [LFC] VerticalMargin should only have the used values.
        https://bugs.webkit.org/show_bug.cgi?id=193168

        Reviewed by NOBODY (OOPS!).

        Split VerticalMargin into ComputedVerticalMargin and UsedVerticalMargin.
        ComputedVerticalMargin holds the computed (optional) values while UsedVerticalMargin holds both the
        collapsed (optional) and the non-collapsed values.

        * layout/FormattingContext.cpp:
        (WebCore::Layout::FormattingContext::computeOutOfFlowVerticalGeometry const):
        * layout/FormattingContext.h:
        * layout/FormattingContextGeometry.cpp:
        (WebCore::Layout::FormattingContext::Geometry::outOfFlowNonReplacedVerticalGeometry):
        (WebCore::Layout::FormattingContext::Geometry::outOfFlowReplacedVerticalGeometry):
        (WebCore::Layout::FormattingContext::Geometry::complicatedCases):
        (WebCore::Layout::FormattingContext::Geometry::inlineReplacedHeightAndMargin):
        (WebCore::Layout::FormattingContext::Geometry::inlineReplacedWidthAndMargin):
        (WebCore::Layout::FormattingContext::Geometry::computedVerticalMargin):
        (WebCore::Layout::FormattingContext::Geometry::computedNonCollapsedVerticalMarginValue): Deleted.
        * layout/FormattingContextQuirks.cpp:
        (WebCore::Layout::FormattingContext::Quirks::heightValueOfNearestContainingBlockWithFixedHeight):
        * layout/LayoutUnits.h:
        * layout/MarginTypes.h:
        (WebCore::Layout::UsedVerticalMargin::before const):
        (WebCore::Layout::UsedVerticalMargin::after const):
        (WebCore::Layout::UsedVerticalMargin::nonCollapsedValues const):
        (WebCore::Layout::UsedVerticalMargin::collapsedValues const):
        (WebCore::Layout::UsedVerticalMargin::hasCollapsedValues const):
        (WebCore::Layout::UsedVerticalMargin::setCollapsedValues):
        (WebCore::Layout::UsedVerticalMargin::UsedVerticalMargin):
        (WebCore::Layout::VerticalMargin::nonCollapsedValues const): Deleted.
        (WebCore::Layout::VerticalMargin::collapsedValues const): Deleted.
        (WebCore::Layout::VerticalMargin::setCollapsedValues): Deleted.
        (WebCore::Layout::VerticalMargin::VerticalMargin): Deleted.
        (WebCore::Layout::VerticalMargin::usedValues const): Deleted.
        * layout/blockformatting/BlockFormattingContext.cpp:
        (WebCore::Layout::BlockFormattingContext::computeHeightAndMargin const):
        * layout/blockformatting/BlockFormattingContextGeometry.cpp:
        (WebCore::Layout::BlockFormattingContext::Geometry::inFlowNonReplacedHeightAndMargin):
        (WebCore::Layout::BlockFormattingContext::Geometry::inFlowHeightAndMargin):
        * layout/blockformatting/BlockFormattingContextQuirks.cpp:
        (WebCore::Layout::BlockFormattingContext::Quirks::stretchedHeight):
        * layout/blockformatting/BlockMarginCollapse.cpp:
        (WebCore::Layout::BlockFormattingContext::Geometry::MarginCollapse::computedNonCollapsedMarginBefore):
        (WebCore::Layout::BlockFormattingContext::Geometry::MarginCollapse::computedNonCollapsedMarginAfter):
        * layout/displaytree/DisplayBox.h:
        (WebCore::Display::Box::setVerticalMargin):
        (WebCore::Display::Box::verticalMargin const):
        (WebCore::Display::Box::marginBefore const):
        (WebCore::Display::Box::marginAfter const):
        * layout/floats/FloatingContext.cpp:
        (WebCore::Layout::FloatingContext::verticalPositionWithClearance const):
        * layout/inlineformatting/InlineFormattingContext.cpp:
        (WebCore::Layout::InlineFormattingContext::computeHeightAndMargin const):

2019-01-04  Zalan Bujtas  <zalan@apple.com>

        [LFC] ComputedHorizontalMargin should have optional members




    auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
    // Margins of absolutely positioned boxes do not collapse
    ASSERT(!verticalGeometry.heightAndMargin.usedMargin.hasCollapsedValues());
    auto nonCollapsedVerticalMargin = verticalGeometry.heightAndMargin.usedMargin.nonCollapsedValues();
    displayBox.setTop(verticalGeometry.top + nonCollapsedVerticalMargin.before);
    displayBox.setContentBoxHeight(verticalGeometry.heightAndMargin.height);
    displayBox.setVerticalMargin(verticalGeometry.heightAndMargin.usedMargin);
}

void FormattingContext::computeBorderAndPadding(const Box& layoutBox) const

Lines 97-103 protected: a/Source/WebCore/layout/FormattingContext.h_sec1
- a/Source/WebCore/layout/FormattingContext.h -1 / +1 lines
97	static Optional<Edges> computedPadding(const LayoutState&, const Box&);	97	static Optional<Edges> computedPadding(const LayoutState&, const Box&);
98		98
99	static ComputedHorizontalMargin computedHorizontalMargin(const LayoutState&, const Box&);	99	static ComputedHorizontalMargin computedHorizontalMargin(const LayoutState&, const Box&);
100	static VerticalMargin::ComputedValues computedNonCollapsedVerticalMarginValue(const LayoutState&, const Box&);	100	static ComputedVerticalMargin computedVerticalMargin(const LayoutState&, const Box&);
101		101
102	static Optional<LayoutUnit> computedValueIfNotAuto(const Length& geometryProperty, LayoutUnit containingBlockWidth);	102	static Optional<LayoutUnit> computedValueIfNotAuto(const Length& geometryProperty, LayoutUnit containingBlockWidth);
103	static Optional<LayoutUnit> fixedValue(const Length& geometryProperty);	103	static Optional<LayoutUnit> fixedValue(const Length& geometryProperty);



    auto top = computedValueIfNotAuto(style.logicalTop(), containingBlockWidth);
    auto bottom = computedValueIfNotAuto(style.logicalBottom(), containingBlockWidth);
    auto height = usedHeight ? usedHeight.value() : computedHeightValue(layoutState, layoutBox, HeightType::Normal);
    auto computedVerticalMargin = Geometry::computedVerticalMargin(layoutState, layoutBox);
    UsedVerticalMargin::NonCollapsedValues usedVerticalMargin; 
    auto usedMarginBefore = computedMarginBefore;
    auto usedMarginAfter = computedMarginAfter;
    auto paddingTop = displayBox.paddingTop().valueOr(0);
    auto paddingBottom = displayBox.paddingBottom().valueOr(0);
    auto borderTop = displayBox.borderTop();

        top = staticVerticalPositionForOutOfFlowPositioned(layoutState, layoutBox);

    if (top && height && bottom) {
        if (!computedVerticalMargin.before && !computedVerticalMargin.after) {
            auto marginBeforeAndAfter = containingBlockHeight - (*top + borderTop + paddingTop + *height + paddingBottom + borderBottom + *bottom);
            usedVerticalMargin = { marginBeforeAndAfter / 2, marginBeforeAndAfter / 2 };
        } else if (!computedVerticalMargin.before) {
            usedVerticalMargin.after = *computedVerticalMargin.after;
            usedVerticalMargin.before = containingBlockHeight - (*top + borderTop + paddingTop + *height + paddingBottom + borderBottom + usedVerticalMargin.after + *bottom);
        } else {
            usedVerticalMargin.before = *computedVerticalMargin.before;
            usedVerticalMargin.after = containingBlockHeight - (*top + usedVerticalMargin.before + borderTop + paddingTop + *height + paddingBottom + borderBottom + *bottom);
        }
        // Over-constrained?
        auto boxHeight = *top + usedVerticalMargin.before + borderTop + paddingTop + *height + paddingBottom + borderBottom + usedVerticalMargin.after + *bottom;
        if (boxHeight > containingBlockHeight)
            bottom = containingBlockHeight - (*top + usedVerticalMargin.before + borderTop + paddingTop + *height + paddingBottom + borderBottom + usedVerticalMargin.after); 
    }

    if (!top && !height && bottom) {
        // #1
        height = contentHeightForFormattingContextRoot(layoutState, layoutBox);
        usedVerticalMargin = { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) };
        top = containingBlockHeight - (usedVerticalMargin.before + borderTop + paddingTop + *height + paddingBottom + borderBottom + usedVerticalMargin.after + *bottom); 
        top = containingBlockHeight - (*usedMarginBefore + borderTop + paddingTop + *height + paddingBottom + borderBottom + *usedMarginAfter + *bottom); 
    }

    if (!top && !bottom && height) {
        // #2
        top = staticVerticalPositionForOutOfFlowPositioned(layoutState, layoutBox);
        usedVerticalMargin = { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) };
        bottom = containingBlockHeight - (*top + usedVerticalMargin.before + borderTop + paddingTop + *height + paddingBottom + borderBottom + usedVerticalMargin.after); 
        bottom = containingBlockHeight - (*top + *usedMarginBefore + borderTop + paddingTop + *height + paddingBottom + borderBottom + *usedMarginAfter); 
    }

    if (!height && !bottom && top) {
        // #3
        height = contentHeightForFormattingContextRoot(layoutState, layoutBox);
        usedVerticalMargin = { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) };
        bottom = containingBlockHeight - (*top + usedVerticalMargin.before + borderTop + paddingTop + *height + paddingBottom + borderBottom + usedVerticalMargin.after); 
        bottom = containingBlockHeight - (*top + *usedMarginBefore + borderTop + paddingTop + *height + paddingBottom + borderBottom + *usedMarginAfter); 
    }

    if (!top && height && bottom) {
        // #4
        usedVerticalMargin = { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) };
        top = containingBlockHeight - (usedVerticalMargin.before + borderTop + paddingTop + *height + paddingBottom + borderBottom + usedVerticalMargin.after + *bottom); 
        top = containingBlockHeight - (*usedMarginBefore + borderTop + paddingTop + *height + paddingBottom + borderBottom + *usedMarginAfter + *bottom); 
    }

    if (!height && top && bottom) {
        // #5
        usedVerticalMargin = { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) };
        height = containingBlockHeight - (*top + usedVerticalMargin.before + borderTop + paddingTop + paddingBottom + borderBottom + usedVerticalMargin.after + *bottom); 
        height = containingBlockHeight - (*top + *usedMarginBefore + borderTop + paddingTop + paddingBottom + borderBottom + *usedMarginAfter + *bottom); 
    }

    if (!bottom && top && height) {
        // #6
        usedVerticalMargin = { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) };
        bottom = containingBlockHeight - (*top + usedVerticalMargin.before + borderTop + paddingTop + *height + paddingBottom + borderBottom + usedVerticalMargin.after); 
        bottom = containingBlockHeight - (*top + *usedMarginBefore + borderTop + paddingTop + *height + paddingBottom + borderBottom + *usedMarginAfter); 
    }

    ASSERT(top);
    ASSERT(bottom);
    ASSERT(height);
    ASSERT(usedMarginBefore);
    ASSERT(usedMarginAfter);

    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Position][Height][Margin] -> out-of-flow non-replaced -> top(" << *top << "px) bottom("  << *bottom << "px) height(" << *height << "px) margin(" << usedVerticalMargin.before << "px, "  << usedVerticalMargin.after << "px) layoutBox(" << &layoutBox << ")");
    return { *top, *bottom, { *height, { usedVerticalMargin, { } } } };
}

HorizontalGeometry FormattingContext::Geometry::outOfFlowNonReplacedHorizontalGeometry(LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedWidth)

    auto top = computedValueIfNotAuto(style.logicalTop(), containingBlockWidth);
    auto bottom = computedValueIfNotAuto(style.logicalBottom(), containingBlockWidth);
    auto height = inlineReplacedHeightAndMargin(layoutState, layoutBox, usedHeight).height;
    auto computedVerticalMargin = Geometry::computedVerticalMargin(layoutState, layoutBox);
    UsedVerticalMargin::NonCollapsedValues usedVerticalMargin; 
    auto usedMarginBefore = computedMarginBefore;
    auto usedMarginAfter = computedMarginAfter;
    auto paddingTop = displayBox.paddingTop().valueOr(0);
    auto paddingBottom = displayBox.paddingBottom().valueOr(0);
    auto borderTop = displayBox.borderTop();


    if (!bottom) {
        // #2
        usedVerticalMargin = { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) };
        usedMarginAfter = usedMarginAfter.valueOr(0);
    }

    if (!computedVerticalMargin.before && !computedVerticalMargin.after) {
        // #3
        auto marginBeforeAndAfter = containingBlockHeight - (*top + borderTop + paddingTop + height + paddingBottom + borderBottom + *bottom);
        usedVerticalMargin = { marginBeforeAndAfter / 2, marginBeforeAndAfter / 2 };
    }

    // #4
    if (!top)
        top = containingBlockHeight - (usedVerticalMargin.before + borderTop + paddingTop + height + paddingBottom + borderBottom + usedVerticalMargin.after + *bottom);

    if (!bottom)
        bottom = containingBlockHeight - (*top + usedVerticalMargin.before + borderTop + paddingTop + height + paddingBottom + borderBottom + usedVerticalMargin.after);

    if (!computedVerticalMargin.before)
        usedVerticalMargin.before = containingBlockHeight - (*top + borderTop + paddingTop + height + paddingBottom + borderBottom + usedVerticalMargin.after + *bottom);

    if (!computedVerticalMargin.after)
        usedVerticalMargin.after = containingBlockHeight - (*top + usedVerticalMargin.before + borderTop + paddingTop + height + paddingBottom + borderBottom + *bottom);

    // #5
    auto boxHeight = *top + usedVerticalMargin.before + borderTop + paddingTop + height + paddingBottom + borderBottom + usedVerticalMargin.after + *bottom;
    if (boxHeight > containingBlockHeight)
        bottom = containingBlockHeight - (*top + usedVerticalMargin.before + borderTop + paddingTop + height + paddingBottom + borderBottom + usedVerticalMargin.after); 

    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Position][Height][Margin] -> out-of-flow replaced -> top(" << *top << "px) bottom("  << *bottom << "px) height(" << height << "px) margin(" << usedVerticalMargin.before << "px, "  << usedVerticalMargin.after << "px) layoutBox(" << &layoutBox << ")");
    return { *top, *bottom, { height, { usedVerticalMargin, { } } } };
}

HorizontalGeometry FormattingContext::Geometry::outOfFlowReplacedHorizontalGeometry(const LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedWidth)

    // 1. If 'margin-top', or 'margin-bottom' are 'auto', their used value is 0.
    // 2. If 'height' is 'auto', the height depends on the element's descendants per 10.6.7.

    auto& style = layoutBox.style();
    auto& containingBlock = *layoutBox.containingBlock();
    auto& containingBlockDisplayBox = layoutState.displayBoxForLayoutBox(containingBlock);
    auto containingBlockWidth = containingBlockDisplayBox.contentBoxWidth();

    auto height = usedHeight ? usedHeight.value() : computedHeightValue(layoutState, layoutBox, HeightType::Normal);
    auto computedVerticalMargin = Geometry::computedVerticalMargin(layoutState, layoutBox);
    auto computedMarginAfter = computedValueIfNotAuto(style.marginAfter(), containingBlockWidth);

    // #1
    auto usedVerticalMargin = UsedVerticalMargin::NonCollapsedValues { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) }; 
    auto usedMarginAfter = computedMarginAfter.valueOr(0);

    // #2
    if (!height) {
        ASSERT(isHeightAuto(layoutBox));


    ASSERT(height);

    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> floating non-replaced -> height(" << *height << "px) margin(" << usedVerticalMargin.before << "px, " << usedVerticalMargin.after << "px) -> layoutBox(" << &layoutBox << ")");
    return HeightAndMargin { *height, { usedVerticalMargin, { } } };
}

WidthAndMargin FormattingContext::Geometry::floatingNonReplacedWidthAndMargin(LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedWidth)

    //    the height of the largest rectangle that has a 2:1 ratio, has a height not greater than 150px, and has a width not greater than the device width.

    // #1
    auto computedVerticalMargin = Geometry::computedVerticalMargin(layoutState, layoutBox);
    auto usedVerticalMargin = UsedVerticalMargin::NonCollapsedValues { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) };
    auto& style = layoutBox.style();
    auto replaced = layoutBox.replaced();



    ASSERT(height);

    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> inflow replaced -> height(" << *height << "px) margin(" << usedVerticalMargin.before << "px, " << usedVerticalMargin.after << "px) -> layoutBox(" << &layoutBox << ")");
    return { *height, { usedVerticalMargin, { } } };
}

WidthAndMargin FormattingContext::Geometry::inlineReplacedWidthAndMargin(const LayoutState& layoutState, const Box& layoutBox,

    //    If 300px is too wide to fit the device, UAs should use the width of the largest rectangle that has a 2:1 ratio and fits the device instead.

    auto& style = layoutBox.style();
    auto& containingBlock = *layoutBox.containingBlock();
    auto containingBlockWidth = layoutState.displayBoxForLayoutBox(containingBlock).contentBoxWidth();
    auto computedHorizontalMargin = Geometry::computedHorizontalMargin(layoutState, layoutBox);

    auto usedMarginStart = [&] {

    return { computedValueIfNotAuto(style.marginStart(), containingBlockWidth), computedValueIfNotAuto(style.marginEnd(), containingBlockWidth) };
}

ComputedVerticalMargin FormattingContext::Geometry::computedVerticalMargin(const LayoutState& layoutState, const Box& layoutBox)
{
    auto& style = layoutBox.style();
    auto containingBlockWidth = layoutState.displayBoxForLayoutBox(*layoutBox.containingBlock()).contentBoxWidth();

    return { computedValueIfNotAuto(style.marginBefore(), containingBlockWidth), computedValueIfNotAuto(style.marginAfter(), containingBlockWidth) };
    auto usedMarginAfter = computedValueIfNotAuto(style.marginAfter(), containingBlockWidth).valueOr(0_lu);

    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Margin] -> non collapsed vertical -> margin(" << usedMarginBefore << "px, " << usedMarginAfter << "px) -> layoutBox: " << &layoutBox);
    return { usedMarginBefore, usedMarginAfter };
}

}



        if (containingBlock->isBodyBox() || containingBlock->isDocumentBox()) {
            auto& displayBox = layoutState.displayBoxForLayoutBox(*containingBlock);

            auto verticalMargin = Geometry::computedVerticalMargin(layoutState, *containingBlock);
            auto verticalPadding = displayBox.paddingTop().valueOr(0) + displayBox.paddingBottom().valueOr(0);
            auto verticalBorder = displayBox.borderTop() + displayBox.borderBottom();
            bodyAndDocumentVerticalMarginPaddingAndBorder += verticalMargin.before.valueOr(0) + verticalMargin.after.valueOr(0) + verticalPadding + verticalBorder;
        }

        containingBlock = containingBlock->containingBlock();

Lines 109-115 struct WidthAndMargin { a/Source/WebCore/layout/LayoutUnits.h_sec1
- a/Source/WebCore/layout/LayoutUnits.h -1 / +1 lines
109		109
110	struct HeightAndMargin {	110	struct HeightAndMargin {
111	LayoutUnit height;	111	LayoutUnit height;
112	VerticalMargin margin;	112	UsedVerticalMargin usedMargin;
113	};	113	};
114		114
115	struct HorizontalGeometry {	115	struct HorizontalGeometry {



namespace WebCore {
namespace Layout {

struct ComputedVerticalMargin {
    Optional<LayoutUnit> before;
    Optional<LayoutUnit> after;
};

struct UsedVerticalMargin {
    LayoutUnit before() const { return m_collapsedValues.before.valueOr(m_nonCollapsedValues.before); }
    LayoutUnit after() const { return m_collapsedValues.after.valueOr(m_nonCollapsedValues.after); }

    struct NonCollapsedValues {
        LayoutUnit before;
        LayoutUnit after;
    };
    NonCollapsedValues nonCollapsedValues() const { return m_nonCollapsedValues; }

    
    struct CollapsedValues {
        Optional<LayoutUnit> before;
        Optional<LayoutUnit> after;
    };
    CollapsedValues collapsedValues() const { return m_collapsedValues; }
    bool hasCollapsedValues() const { return m_collapsedValues.before || m_collapsedValues.after; }
    void setCollapsedValues(CollapsedValues collapsedValues) { m_collapsedValues = collapsedValues; }

    UsedVerticalMargin(NonCollapsedValues, CollapsedValues);

    UsedVerticalMargin() = default;
    ~UsedVerticalMargin() = default;
private:
    NonCollapsedValues m_nonCollapsedValues;
    CollapsedValues m_collapsedValues;
};

struct ComputedHorizontalMargin {

    Values after;
};

inline UsedVerticalMargin::UsedVerticalMargin(UsedVerticalMargin::NonCollapsedValues nonCollapsedValues, UsedVerticalMargin::CollapsedValues collapsedValues)
    : m_nonCollapsedValues(nonCollapsedValues)
    , m_collapsedValues(collapsedValues)
{
}

inline VerticalMargin::ComputedValues VerticalMargin::usedValues() const
{
    if (!m_collapsed)
        return m_nonCollapsed;
    return { m_collapsed->before.valueOr(m_nonCollapsed.before),
        m_collapsed->after.valueOr(m_nonCollapsed.after) };
}

}



            auto maxHeightAndMargin = compute(maxHeight);
            // Used height should remain the same.
            ASSERT((layoutState.inQuirksMode() && (layoutBox.isBodyBox() || layoutBox.isDocumentBox())) || maxHeightAndMargin.height == *maxHeight);
            heightAndMargin = { *maxHeight, maxHeightAndMargin.usedMargin };
        }
    }


            auto minHeightAndMargin = compute(minHeight);
            // Used height should remain the same.
            ASSERT((layoutState.inQuirksMode() && (layoutBox.isBodyBox() || layoutBox.isDocumentBox())) || minHeightAndMargin.height == *minHeight);
            heightAndMargin = { *minHeight, minHeightAndMargin.usedMargin };
        }
    }

    auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
    displayBox.setContentBoxHeight(heightAndMargin.height);
    displayBox.setVerticalMargin(heightAndMargin.usedMargin);

    // If this box has already been moved by the estimated vertical margin, no need to move it again.
    if (layoutBox.isFloatingPositioned() || !displayBox.estimatedMarginBefore())
        displayBox.moveVertically(heightAndMargin.usedMargin.before());
}

FormattingContext::InstrinsicWidthConstraints BlockFormattingContext::instrinsicWidthConstraints() const



        // Only children in the normal flow are taken into account (i.e., floating boxes and absolutely positioned boxes are ignored,
        // and relatively positioned boxes are considered without their offset). Note that the child box may be an anonymous block box.

        auto& style = layoutBox.style();
        auto containingBlockWidth = layoutState.displayBoxForLayoutBox(*layoutBox.containingBlock()).contentBoxWidth();
        auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
        auto computedVerticalMargin = Geometry::computedVerticalMargin(layoutState, layoutBox);
        auto nonCollapsedMargin = UsedVerticalMargin::NonCollapsedValues { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) }; 
        auto collapsedMargin = UsedVerticalMargin::CollapsedValues { MarginCollapse::marginBefore(layoutState, layoutBox), MarginCollapse::marginAfter(layoutState, layoutBox) };
        auto collapsedMargin = VerticalMargin::CollapsedValues { MarginCollapse::marginBefore(layoutState, layoutBox), MarginCollapse::marginAfter(layoutState, layoutBox) };
        auto borderAndPaddingTop = displayBox.borderTop() + displayBox.paddingTop().valueOr(0);

        auto height = usedHeight ? usedHeight.value() : computedHeightValue(layoutState, layoutBox, HeightType::Normal);


    auto heightAndMargin = compute();

    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> inflow non-replaced -> height(" << heightAndMargin.height << "px) margin(" << heightAndMargin.usedMargin.before() << "px, " << heightAndMargin.usedMargin.after() << "px) -> layoutBox(" << &layoutBox << ")");
    return heightAndMargin;
}



    heightAndMargin = Quirks::stretchedHeight(layoutState, layoutBox, heightAndMargin);

    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> inflow non-replaced -> streched to viewport -> height(" << heightAndMargin.height << "px) margin(" << heightAndMargin.usedMargin.before() << "px, " << heightAndMargin.usedMargin.after() << "px) -> layoutBox(" << &layoutBox << ")");
    return heightAndMargin;
}





    LayoutUnit totalVerticalMargin;
    if (layoutBox.isDocumentBox()) {
        auto verticalMargin = heightAndMargin.usedMargin;
        // Document box's margins do not collapse.
        ASSERT(!verticalMargin.hasCollapsedValues());
        totalVerticalMargin = verticalMargin.before() + verticalMargin.after();
    } else if (layoutBox.isBodyBox()) {
        // Here is the quirky part for body box:
        // Stretch the body using the initial containing block's height and shrink it with document box's margin/border/padding.


        // This quirk happens when the body height is 0 which means its vertical margins collapse through (top and bottom margins are adjoining).
        // However now that we stretch the body they don't collapse through anymore, so we need to use the non-collapsed values instead.
        if (heightAndMargin.height)
            totalVerticalMargin = heightAndMargin.usedMargin.before() + heightAndMargin.usedMargin.after();
        else {
            auto nonCollapsedValues = heightAndMargin.usedMargin.nonCollapsedValues();
            totalVerticalMargin = nonCollapsedValues.before + nonCollapsedValues.after;
        }
    }

    // Stretch but never overstretch with the margins.



{
    ASSERT(layoutBox.isBlockLevelBox());

    return computedVerticalMargin(layoutState, layoutBox).before.valueOr(0);
}

LayoutUnit BlockFormattingContext::Geometry::MarginCollapse::computedNonCollapsedMarginAfter(const LayoutState& layoutState, const Box& layoutBox)
{
    ASSERT(layoutBox.isBlockLevelBox());

    return computedVerticalMargin(layoutState, layoutBox).after.valueOr(0);
}

LayoutUnit BlockFormattingContext::Geometry::MarginCollapse::nonCollapsedMarginBefore(const LayoutState& layoutState, const Box& layoutBox)



    Rect rect() const { return { top(), left(), width(), height() }; }
    Rect rectWithMargin() const { return { top() - marginBefore(), left() - marginStart(), marginStart() + width() + marginEnd(), marginBefore() + height() + marginAfter() }; }

    Layout::UsedVerticalMargin verticalMargin() const;
    LayoutUnit marginBefore() const;
    LayoutUnit marginStart() const;
    LayoutUnit marginAfter() const;

    void setContentBoxWidth(LayoutUnit);

    void setHorizontalMargin(Layout::UsedHorizontalMargin);
    void setVerticalMargin(Layout::UsedVerticalMargin);
    void setHorizontalComputedMargin(Layout::ComputedHorizontalMargin);
    void setEstimatedMarginBefore(LayoutUnit marginBefore) { m_estimatedMarginBefore = marginBefore; }


    LayoutUnit m_contentHeight;

    Layout::UsedHorizontalMargin m_horizontalMargin;
    Layout::UsedVerticalMargin m_verticalMargin;
    Layout::ComputedHorizontalMargin m_horizontalComputedMargin;
    Optional<LayoutUnit> m_estimatedMarginBefore;


    m_horizontalMargin = margin;
}

inline void Box::setVerticalMargin(Layout::UsedVerticalMargin margin)
{
#if !ASSERT_DISABLED
    setHasValidVerticalMargin();
    setHasValidVerticalNonCollapsedMargin();
#endif
    ASSERT(!m_estimatedMarginBefore || *m_estimatedMarginBefore == margin.before());
    m_verticalMargin = margin;
}


    m_padding = padding;
}

inline Layout::UsedVerticalMargin Box::verticalMargin() const
{
    ASSERT(m_hasValidVerticalMargin);
    return m_verticalMargin;

inline LayoutUnit Box::marginBefore() const
{
    ASSERT(m_hasValidVerticalMargin);
    return m_verticalMargin.before();
}

inline LayoutUnit Box::marginStart() const

inline LayoutUnit Box::marginAfter() const
{
    ASSERT(m_hasValidVerticalMargin);
    return m_verticalMargin.after();
}

inline LayoutUnit Box::marginEnd() const




            // Reset previous bottom and current top margins to non-collapsing.
            auto previousVerticalMargin = previousInFlowDisplayBox.verticalMargin();
            if (previousVerticalMargin.collapsedValues().after) {
                previousVerticalMargin.setCollapsedValues({ previousVerticalMargin.collapsedValues().before, { } });
                previousInFlowDisplayBox.setVerticalMargin(previousVerticalMargin);
            }
            // FIXME: check if collapsing through has anything to do with this.
            auto verticalMargin = displayBox.verticalMargin();
            if (verticalMargin.collapsedValues().before) {
                verticalMargin.setCollapsedValues({ { }, verticalMargin.collapsedValues().after });
                displayBox.setVerticalMargin(verticalMargin);
            }


Lines 362-368 void InlineFormattingContext::computeHeightAndMargin(const Box& layoutBox) const a/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp_sec1
- a/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp -1 / +1 lines
362		362
363	auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);	363	auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
364	displayBox.setContentBoxHeight(heightAndMargin.height);	364	displayBox.setContentBoxHeight(heightAndMargin.height);
365	displayBox.setVerticalMargin(heightAndMargin.margin);	365	displayBox.setVerticalMargin(heightAndMargin.usedMargin);
366	}	366	}
367		367
368	void InlineFormattingContext::layoutFormattingContextRoot(const Box& root) const	368	void InlineFormattingContext::layoutFormattingContextRoot(const Box& root) const

Return to Bug 193168

Lines 116-126 void FormattingContext::computeOutOfFlowVerticalGeometry(const Box& layoutBox) c a/Source/WebCore/layout/FormattingContext.cpp_sec1
- a/Source/WebCore/layout/FormattingContext.cpp -3 / +3 lines
116		116
117	auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);	117	auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
118	// Margins of absolutely positioned boxes do not collapse	118	// Margins of absolutely positioned boxes do not collapse
119	ASSERT(!verticalGeometry.heightAndMargin.margin.collapsedValues());	119	ASSERT(!verticalGeometry.heightAndMargin.usedMargin.hasCollapsedValues());
120	auto nonCollapsedVerticalMargin = verticalGeometry.heightAndMargin.margin.nonCollapsedValues();	120	auto nonCollapsedVerticalMargin = verticalGeometry.heightAndMargin.usedMargin.nonCollapsedValues();
121	displayBox.setTop(verticalGeometry.top + nonCollapsedVerticalMargin.before);	121	displayBox.setTop(verticalGeometry.top + nonCollapsedVerticalMargin.before);
122	displayBox.setContentBoxHeight(verticalGeometry.heightAndMargin.height);	122	displayBox.setContentBoxHeight(verticalGeometry.heightAndMargin.height);
123	displayBox.setVerticalMargin(verticalGeometry.heightAndMargin.margin);	123	displayBox.setVerticalMargin(verticalGeometry.heightAndMargin.usedMargin);
124	}	124	}
125		125
126	void FormattingContext::computeBorderAndPadding(const Box& layoutBox) const	126	void FormattingContext::computeBorderAndPadding(const Box& layoutBox) const

Lines 51-60 LayoutUnit FormattingContext::Quirks::heightValueOfNearestContainingBlockWithFix a/Source/WebCore/layout/FormattingContextQuirks.cpp_sec1
- a/Source/WebCore/layout/FormattingContextQuirks.cpp -2 / +2 lines
51	if (containingBlock->isBodyBox() \|\| containingBlock->isDocumentBox()) {	51	if (containingBlock->isBodyBox() \|\| containingBlock->isDocumentBox()) {
52	auto& displayBox = layoutState.displayBoxForLayoutBox(*containingBlock);	52	auto& displayBox = layoutState.displayBoxForLayoutBox(*containingBlock);
53		53
54	auto verticalMargin = FormattingContext::Geometry::computedNonCollapsedVerticalMarginValue(layoutState, *containingBlock);	54	auto verticalMargin = Geometry::computedVerticalMargin(layoutState, *containingBlock);
55	auto verticalPadding = displayBox.paddingTop().valueOr(0) + displayBox.paddingBottom().valueOr(0);	55	auto verticalPadding = displayBox.paddingTop().valueOr(0) + displayBox.paddingBottom().valueOr(0);
56	auto verticalBorder = displayBox.borderTop() + displayBox.borderBottom();	56	auto verticalBorder = displayBox.borderTop() + displayBox.borderBottom();
57	bodyAndDocumentVerticalMarginPaddingAndBorder += verticalMargin.before + verticalMargin.after + verticalPadding + verticalBorder;	57	bodyAndDocumentVerticalMarginPaddingAndBorder += verticalMargin.before.valueOr(0) + verticalMargin.after.valueOr(0) + verticalPadding + verticalBorder;
58	}	58	}
59		59
60	containingBlock = containingBlock->containingBlock();	60	containingBlock = containingBlock->containingBlock();

Lines 32-59 a/Source/WebCore/layout/MarginTypes.h_sec1
- a/Source/WebCore/layout/MarginTypes.h -23 / +23 lines
32	namespace WebCore {	32	namespace WebCore {
33	namespace Layout {	33	namespace Layout {
34		34
35	struct VerticalMargin {	35	struct ComputedVerticalMargin {
36	struct ComputedValues {	36	Optional<LayoutUnit> before;
		37	Optional<LayoutUnit> after;
		38	};
		39
		40	struct UsedVerticalMargin {
		41	LayoutUnit before() const { return m_collapsedValues.before.valueOr(m_nonCollapsedValues.before); }
		42	LayoutUnit after() const { return m_collapsedValues.after.valueOr(m_nonCollapsedValues.after); }
		43
		44	struct NonCollapsedValues {
37	LayoutUnit before;	45	LayoutUnit before;
38	LayoutUnit after;	46	LayoutUnit after;
39	};	47	};
40	ComputedValues usedValues() const;	48	NonCollapsedValues nonCollapsedValues() const { return m_nonCollapsedValues; }
41	ComputedValues nonCollapsedValues() const { return m_nonCollapsed; }	49
42
43	struct CollapsedValues {	50	struct CollapsedValues {
44	Optional<LayoutUnit> before;	51	Optional<LayoutUnit> before;
45	Optional<LayoutUnit> after;	52	Optional<LayoutUnit> after;
46	};	53	};
47	Optional<CollapsedValues> collapsedValues() const { return m_collapsed; }	54	CollapsedValues collapsedValues() const { return m_collapsedValues; }
48	void setCollapsedValues(CollapsedValues collapsedValues) { m_collapsed = collapsedValues; }	55	bool hasCollapsedValues() const { return m_collapsedValues.before \|\| m_collapsedValues.after; }
		56	void setCollapsedValues(CollapsedValues collapsedValues) { m_collapsedValues = collapsedValues; }
49		57
50	VerticalMargin(ComputedValues nonCollapsed, Optional<CollapsedValues>);	58	UsedVerticalMargin(NonCollapsedValues, CollapsedValues);
51		59
52	VerticalMargin() = default;	60	UsedVerticalMargin() = default;
53	~VerticalMargin() = default;	61	~UsedVerticalMargin() = default;
54	private:	62	private:
55	ComputedValues m_nonCollapsed;	63	NonCollapsedValues m_nonCollapsedValues;
56	Optional<CollapsedValues> m_collapsed;	64	CollapsedValues m_collapsedValues;
57	};	65	};
58		66
59	struct ComputedHorizontalMargin {	67	struct ComputedHorizontalMargin {
Lines 75-92 struct PositiveAndNegativeVerticalMargin { a/Source/WebCore/layout/MarginTypes.h_sec2
75	Values after;	83	Values after;
76	};	84	};
77		85
78	inline VerticalMargin::VerticalMargin(VerticalMargin::ComputedValues nonCollapsed, Optional<VerticalMargin::CollapsedValues> collapsed)	86	inline UsedVerticalMargin::UsedVerticalMargin(UsedVerticalMargin::NonCollapsedValues nonCollapsedValues, UsedVerticalMargin::CollapsedValues collapsedValues)
79	: m_nonCollapsed(nonCollapsed)	87	: m_nonCollapsedValues(nonCollapsedValues)
80	, m_collapsed(collapsed)	88	, m_collapsedValues(collapsedValues)
81	{
82	}
83
84	inline VerticalMargin::ComputedValues VerticalMargin::usedValues() const
85	{	89	{
86	if (!m_collapsed)
87	return m_nonCollapsed;
88	return { m_collapsed->before.valueOr(m_nonCollapsed.before),
89	m_collapsed->after.valueOr(m_nonCollapsed.after) };
90	}	90	}
91		91
92	}	92	}

Lines 138-144 public: a/Source/WebCore/layout/displaytree/DisplayBox.h_sec1
- a/Source/WebCore/layout/displaytree/DisplayBox.h -8 / +8 lines
138	Rect rect() const { return { top(), left(), width(), height() }; }	138	Rect rect() const { return { top(), left(), width(), height() }; }
139	Rect rectWithMargin() const { return { top() - marginBefore(), left() - marginStart(), marginStart() + width() + marginEnd(), marginBefore() + height() + marginAfter() }; }	139	Rect rectWithMargin() const { return { top() - marginBefore(), left() - marginStart(), marginStart() + width() + marginEnd(), marginBefore() + height() + marginAfter() }; }
140		140
141	Layout::VerticalMargin verticalMargin() const;	141	Layout::UsedVerticalMargin verticalMargin() const;
142	LayoutUnit marginBefore() const;	142	LayoutUnit marginBefore() const;
143	LayoutUnit marginStart() const;	143	LayoutUnit marginStart() const;
144	LayoutUnit marginAfter() const;	144	LayoutUnit marginAfter() const;
Lines 192-198 private: a/Source/WebCore/layout/displaytree/DisplayBox.h_sec2
192	void setContentBoxWidth(LayoutUnit);	192	void setContentBoxWidth(LayoutUnit);
193		193
194	void setHorizontalMargin(Layout::UsedHorizontalMargin);	194	void setHorizontalMargin(Layout::UsedHorizontalMargin);
195	void setVerticalMargin(Layout::VerticalMargin);	195	void setVerticalMargin(Layout::UsedVerticalMargin);
196	void setHorizontalComputedMargin(Layout::ComputedHorizontalMargin);	196	void setHorizontalComputedMargin(Layout::ComputedHorizontalMargin);
197	void setEstimatedMarginBefore(LayoutUnit marginBefore) { m_estimatedMarginBefore = marginBefore; }	197	void setEstimatedMarginBefore(LayoutUnit marginBefore) { m_estimatedMarginBefore = marginBefore; }
198		198
Lines 225-231 private: a/Source/WebCore/layout/displaytree/DisplayBox.h_sec3
225	LayoutUnit m_contentHeight;	225	LayoutUnit m_contentHeight;
226		226
227	Layout::UsedHorizontalMargin m_horizontalMargin;	227	Layout::UsedHorizontalMargin m_horizontalMargin;
228	Layout::VerticalMargin m_verticalMargin;	228	Layout::UsedVerticalMargin m_verticalMargin;
229	Layout::ComputedHorizontalMargin m_horizontalComputedMargin;	229	Layout::ComputedHorizontalMargin m_horizontalComputedMargin;
230	Optional<LayoutUnit> m_estimatedMarginBefore;	230	Optional<LayoutUnit> m_estimatedMarginBefore;
231		231
Lines 515-527 inline void Box::setHorizontalMargin(Layout::UsedHorizontalMargin margin) a/Source/WebCore/layout/displaytree/DisplayBox.h_sec4
515	m_horizontalMargin = margin;	515	m_horizontalMargin = margin;
516	}	516	}
517		517
518	inline void Box::setVerticalMargin(Layout::VerticalMargin margin)	518	inline void Box::setVerticalMargin(Layout::UsedVerticalMargin margin)
519	{	519	{
520	#if !ASSERT_DISABLED	520	#if !ASSERT_DISABLED
521	setHasValidVerticalMargin();	521	setHasValidVerticalMargin();
522	setHasValidVerticalNonCollapsedMargin();	522	setHasValidVerticalNonCollapsedMargin();
523	#endif	523	#endif
524	ASSERT(!m_estimatedMarginBefore \|\| *m_estimatedMarginBefore == margin.usedValues().before);	524	ASSERT(!m_estimatedMarginBefore \|\| *m_estimatedMarginBefore == margin.before());
525	m_verticalMargin = margin;	525	m_verticalMargin = margin;
526	}	526	}
527		527
Lines 549-555 inline void Box::setPadding(Optional<Layout::Edges> padding) a/Source/WebCore/layout/displaytree/DisplayBox.h_sec5
549	m_padding = padding;	549	m_padding = padding;
550	}	550	}
551		551
552	inline Layout::VerticalMargin Box::verticalMargin() const	552	inline Layout::UsedVerticalMargin Box::verticalMargin() const
553	{	553	{
554	ASSERT(m_hasValidVerticalMargin);	554	ASSERT(m_hasValidVerticalMargin);
555	return m_verticalMargin;	555	return m_verticalMargin;
Lines 558-564 inline Layout::VerticalMargin Box::verticalMargin() const a/Source/WebCore/layout/displaytree/DisplayBox.h_sec6
558	inline LayoutUnit Box::marginBefore() const	558	inline LayoutUnit Box::marginBefore() const
559	{	559	{
560	ASSERT(m_hasValidVerticalMargin);	560	ASSERT(m_hasValidVerticalMargin);
561	return m_verticalMargin.usedValues().before;	561	return m_verticalMargin.before();
562	}	562	}
563		563
564	inline LayoutUnit Box::marginStart() const	564	inline LayoutUnit Box::marginStart() const
Lines 570-576 inline LayoutUnit Box::marginStart() const a/Source/WebCore/layout/displaytree/DisplayBox.h_sec7
570	inline LayoutUnit Box::marginAfter() const	570	inline LayoutUnit Box::marginAfter() const
571	{	571	{
572	ASSERT(m_hasValidVerticalMargin);	572	ASSERT(m_hasValidVerticalMargin);
573	return m_verticalMargin.usedValues().after;	573	return m_verticalMargin.after();
574	}	574	}
575		575
576	inline LayoutUnit Box::marginEnd() const	576	inline LayoutUnit Box::marginEnd() const

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +58 lines
		1	2019-01-04 Zalan Bujtas <zalan@apple.com>
		2
		3	[LFC] VerticalMargin should only have the used values.
		4	https://bugs.webkit.org/show_bug.cgi?id=193168
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Split VerticalMargin into ComputedVerticalMargin and UsedVerticalMargin.
		9	ComputedVerticalMargin holds the computed (optional) values while UsedVerticalMargin holds both the
		10	collapsed (optional) and the non-collapsed values.
		11
		12	* layout/FormattingContext.cpp:
		13	(WebCore::Layout::FormattingContext::computeOutOfFlowVerticalGeometry const):
		14	* layout/FormattingContext.h:
		15	* layout/FormattingContextGeometry.cpp:
		16	(WebCore::Layout::FormattingContext::Geometry::outOfFlowNonReplacedVerticalGeometry):
		17	(WebCore::Layout::FormattingContext::Geometry::outOfFlowReplacedVerticalGeometry):
		18	(WebCore::Layout::FormattingContext::Geometry::complicatedCases):
		19	(WebCore::Layout::FormattingContext::Geometry::inlineReplacedHeightAndMargin):
		20	(WebCore::Layout::FormattingContext::Geometry::inlineReplacedWidthAndMargin):
		21	(WebCore::Layout::FormattingContext::Geometry::computedVerticalMargin):
		22	(WebCore::Layout::FormattingContext::Geometry::computedNonCollapsedVerticalMarginValue): Deleted.
		23	* layout/FormattingContextQuirks.cpp:
		24	(WebCore::Layout::FormattingContext::Quirks::heightValueOfNearestContainingBlockWithFixedHeight):
		25	* layout/LayoutUnits.h:
		26	* layout/MarginTypes.h:
		27	(WebCore::Layout::UsedVerticalMargin::before const):
		28	(WebCore::Layout::UsedVerticalMargin::after const):
		29	(WebCore::Layout::UsedVerticalMargin::nonCollapsedValues const):
		30	(WebCore::Layout::UsedVerticalMargin::collapsedValues const):
		31	(WebCore::Layout::UsedVerticalMargin::hasCollapsedValues const):
		32	(WebCore::Layout::UsedVerticalMargin::setCollapsedValues):
		33	(WebCore::Layout::UsedVerticalMargin::UsedVerticalMargin):
		34	(WebCore::Layout::VerticalMargin::nonCollapsedValues const): Deleted.
		35	(WebCore::Layout::VerticalMargin::collapsedValues const): Deleted.
		36	(WebCore::Layout::VerticalMargin::setCollapsedValues): Deleted.
		37	(WebCore::Layout::VerticalMargin::VerticalMargin): Deleted.
		38	(WebCore::Layout::VerticalMargin::usedValues const): Deleted.
		39	* layout/blockformatting/BlockFormattingContext.cpp:
		40	(WebCore::Layout::BlockFormattingContext::computeHeightAndMargin const):
		41	* layout/blockformatting/BlockFormattingContextGeometry.cpp:
		42	(WebCore::Layout::BlockFormattingContext::Geometry::inFlowNonReplacedHeightAndMargin):
		43	(WebCore::Layout::BlockFormattingContext::Geometry::inFlowHeightAndMargin):
		44	* layout/blockformatting/BlockFormattingContextQuirks.cpp:
		45	(WebCore::Layout::BlockFormattingContext::Quirks::stretchedHeight):
		46	* layout/blockformatting/BlockMarginCollapse.cpp:
		47	(WebCore::Layout::BlockFormattingContext::Geometry::MarginCollapse::computedNonCollapsedMarginBefore):
		48	(WebCore::Layout::BlockFormattingContext::Geometry::MarginCollapse::computedNonCollapsedMarginAfter):
		49	* layout/displaytree/DisplayBox.h:
		50	(WebCore::Display::Box::setVerticalMargin):
		51	(WebCore::Display::Box::verticalMargin const):
		52	(WebCore::Display::Box::marginBefore const):
		53	(WebCore::Display::Box::marginAfter const):
		54	* layout/floats/FloatingContext.cpp:
		55	(WebCore::Layout::FloatingContext::verticalPositionWithClearance const):
		56	* layout/inlineformatting/InlineFormattingContext.cpp:
		57	(WebCore::Layout::InlineFormattingContext::computeHeightAndMargin const):
		58
1	2019-01-04 Zalan Bujtas <zalan@apple.com>	59	2019-01-04 Zalan Bujtas <zalan@apple.com>
2		60
3	[LFC] ComputedHorizontalMargin should have optional members	61	[LFC] ComputedHorizontalMargin should have optional members

Lines 358-364 void BlockFormattingContext::computeHeightAndMargin(const Box& layoutBox) const a/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp_sec1
- a/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp -4 / +4 lines
358	auto maxHeightAndMargin = compute(maxHeight);	358	auto maxHeightAndMargin = compute(maxHeight);
359	// Used height should remain the same.	359	// Used height should remain the same.
360	ASSERT((layoutState.inQuirksMode() && (layoutBox.isBodyBox() \|\| layoutBox.isDocumentBox())) \|\| maxHeightAndMargin.height == *maxHeight);	360	ASSERT((layoutState.inQuirksMode() && (layoutBox.isBodyBox() \|\| layoutBox.isDocumentBox())) \|\| maxHeightAndMargin.height == *maxHeight);
361	heightAndMargin = { *maxHeight, maxHeightAndMargin.margin };	361	heightAndMargin = { *maxHeight, maxHeightAndMargin.usedMargin };
362	}	362	}
363	}	363	}
364		364
Lines 367-383 void BlockFormattingContext::computeHeightAndMargin(const Box& layoutBox) const a/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp_sec2
367	auto minHeightAndMargin = compute(minHeight);	367	auto minHeightAndMargin = compute(minHeight);
368	// Used height should remain the same.	368	// Used height should remain the same.
369	ASSERT((layoutState.inQuirksMode() && (layoutBox.isBodyBox() \|\| layoutBox.isDocumentBox())) \|\| minHeightAndMargin.height == *minHeight);	369	ASSERT((layoutState.inQuirksMode() && (layoutBox.isBodyBox() \|\| layoutBox.isDocumentBox())) \|\| minHeightAndMargin.height == *minHeight);
370	heightAndMargin = { *minHeight, minHeightAndMargin.margin };	370	heightAndMargin = { *minHeight, minHeightAndMargin.usedMargin };
371	}	371	}
372	}	372	}
373		373
374	auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);	374	auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
375	displayBox.setContentBoxHeight(heightAndMargin.height);	375	displayBox.setContentBoxHeight(heightAndMargin.height);
376	displayBox.setVerticalMargin(heightAndMargin.margin);	376	displayBox.setVerticalMargin(heightAndMargin.usedMargin);
377		377
378	// If this box has already been moved by the estimated vertical margin, no need to move it again.	378	// If this box has already been moved by the estimated vertical margin, no need to move it again.
379	if (layoutBox.isFloatingPositioned() \|\| !displayBox.estimatedMarginBefore())	379	if (layoutBox.isFloatingPositioned() \|\| !displayBox.estimatedMarginBefore())
380	displayBox.moveVertically(heightAndMargin.margin.usedValues().before);	380	displayBox.moveVertically(heightAndMargin.usedMargin.before());
381	}	381	}
382		382
383	FormattingContext::InstrinsicWidthConstraints BlockFormattingContext::instrinsicWidthConstraints() const	383	FormattingContext::InstrinsicWidthConstraints BlockFormattingContext::instrinsicWidthConstraints() const

Lines 57-69 HeightAndMargin BlockFormattingContext::Geometry::inFlowNonReplacedHeightAndMarg a/Source/WebCore/layout/blockformatting/BlockFormattingContextGeometry.cpp_sec1
- a/Source/WebCore/layout/blockformatting/BlockFormattingContextGeometry.cpp -8 / +5 lines
57	// Only children in the normal flow are taken into account (i.e., floating boxes and absolutely positioned boxes are ignored,	57	// Only children in the normal flow are taken into account (i.e., floating boxes and absolutely positioned boxes are ignored,
58	// and relatively positioned boxes are considered without their offset). Note that the child box may be an anonymous block box.	58	// and relatively positioned boxes are considered without their offset). Note that the child box may be an anonymous block box.
59		59
60	auto& style = layoutBox.style();
61	auto containingBlockWidth = layoutState.displayBoxForLayoutBox(*layoutBox.containingBlock()).contentBoxWidth();
62	auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);	60	auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
63		61	auto computedVerticalMargin = Geometry::computedVerticalMargin(layoutState, layoutBox);
64	auto nonCollapsedMargin = VerticalMargin::ComputedValues { computedValueIfNotAuto(style.marginBefore(), containingBlockWidth).valueOr(0),	62	auto nonCollapsedMargin = UsedVerticalMargin::NonCollapsedValues { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) };
65	computedValueIfNotAuto(style.marginAfter(), containingBlockWidth).valueOr(0) };	63	auto collapsedMargin = UsedVerticalMargin::CollapsedValues { MarginCollapse::marginBefore(layoutState, layoutBox), MarginCollapse::marginAfter(layoutState, layoutBox) };
66	auto collapsedMargin = VerticalMargin::CollapsedValues { MarginCollapse::marginBefore(layoutState, layoutBox), MarginCollapse::marginAfter(layoutState, layoutBox) };
67	auto borderAndPaddingTop = displayBox.borderTop() + displayBox.paddingTop().valueOr(0);	64	auto borderAndPaddingTop = displayBox.borderTop() + displayBox.paddingTop().valueOr(0);
68		65
69	auto height = usedHeight ? usedHeight.value() : computedHeightValue(layoutState, layoutBox, HeightType::Normal);	66	auto height = usedHeight ? usedHeight.value() : computedHeightValue(layoutState, layoutBox, HeightType::Normal);
Lines 104-110 HeightAndMargin BlockFormattingContext::Geometry::inFlowNonReplacedHeightAndMarg a/Source/WebCore/layout/blockformatting/BlockFormattingContextGeometry.cpp_sec2
104		101
105	auto heightAndMargin = compute();	102	auto heightAndMargin = compute();
106		103
107	LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> inflow non-replaced -> height(" << heightAndMargin.height << "px) margin(" << heightAndMargin.margin.usedValues().before << "px, " << heightAndMargin.margin.usedValues().after << "px) -> layoutBox(" << &layoutBox << ")");	104	LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> inflow non-replaced -> height(" << heightAndMargin.height << "px) margin(" << heightAndMargin.usedMargin.before() << "px, " << heightAndMargin.usedMargin.after() << "px) -> layoutBox(" << &layoutBox << ")");
108	return heightAndMargin;	105	return heightAndMargin;
109	}	106	}
110		107
Lines 263-269 HeightAndMargin BlockFormattingContext::Geometry::inFlowHeightAndMargin(const La a/Source/WebCore/layout/blockformatting/BlockFormattingContextGeometry.cpp_sec3
263		260
264	heightAndMargin = Quirks::stretchedHeight(layoutState, layoutBox, heightAndMargin);	261	heightAndMargin = Quirks::stretchedHeight(layoutState, layoutBox, heightAndMargin);
265		262
266	LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> inflow non-replaced -> streched to viewport -> height(" << heightAndMargin.height << "px) margin(" << heightAndMargin.margin.usedValues().before << "px, " << heightAndMargin.margin.usedValues().after << "px) -> layoutBox(" << &layoutBox << ")");	263	LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> inflow non-replaced -> streched to viewport -> height(" << heightAndMargin.height << "px) margin(" << heightAndMargin.usedMargin.before() << "px, " << heightAndMargin.usedMargin.after() << "px) -> layoutBox(" << &layoutBox << ")");
267	return heightAndMargin;	264	return heightAndMargin;
268	}	265	}
269		266

Lines 80-89 HeightAndMargin BlockFormattingContext::Quirks::stretchedHeight(const LayoutStat a/Source/WebCore/layout/blockformatting/BlockFormattingContextQuirks.cpp_sec1
- a/Source/WebCore/layout/blockformatting/BlockFormattingContextQuirks.cpp -5 / +9 lines
80		80
81	LayoutUnit totalVerticalMargin;	81	LayoutUnit totalVerticalMargin;
82	if (layoutBox.isDocumentBox()) {	82	if (layoutBox.isDocumentBox()) {
83	auto verticalMargin = heightAndMargin.margin.usedValues();	83	auto verticalMargin = heightAndMargin.usedMargin;
84	// Document box's margins do not collapse.	84	// Document box's margins do not collapse.
85	ASSERT(!heightAndMargin.margin.collapsedValues());	85	ASSERT(!verticalMargin.hasCollapsedValues());
86	totalVerticalMargin = verticalMargin.before + verticalMargin.after;	86	totalVerticalMargin = verticalMargin.before() + verticalMargin.after();
87	} else if (layoutBox.isBodyBox()) {	87	} else if (layoutBox.isBodyBox()) {
88	// Here is the quirky part for body box:	88	// Here is the quirky part for body box:
89	// Stretch the body using the initial containing block's height and shrink it with document box's margin/border/padding.	89	// Stretch the body using the initial containing block's height and shrink it with document box's margin/border/padding.
Lines 93-100 HeightAndMargin BlockFormattingContext::Quirks::stretchedHeight(const LayoutStat a/Source/WebCore/layout/blockformatting/BlockFormattingContextQuirks.cpp_sec2
93		93
94	// This quirk happens when the body height is 0 which means its vertical margins collapse through (top and bottom margins are adjoining).	94	// This quirk happens when the body height is 0 which means its vertical margins collapse through (top and bottom margins are adjoining).
95	// However now that we stretch the body they don't collapse through anymore, so we need to use the non-collapsed values instead.	95	// However now that we stretch the body they don't collapse through anymore, so we need to use the non-collapsed values instead.
96	auto bodyBoxVerticalMargin = heightAndMargin.height ? heightAndMargin.margin.usedValues() : heightAndMargin.margin.nonCollapsedValues();	96	if (heightAndMargin.height)
97	totalVerticalMargin = bodyBoxVerticalMargin.before + bodyBoxVerticalMargin.after;	97	totalVerticalMargin = heightAndMargin.usedMargin.before() + heightAndMargin.usedMargin.after();
		98	else {
		99	auto nonCollapsedValues = heightAndMargin.usedMargin.nonCollapsedValues();
		100	totalVerticalMargin = nonCollapsedValues.before + nonCollapsedValues.after;
		101	}
98	}	102	}
99		103
100	// Stretch but never overstretch with the margins.	104	// Stretch but never overstretch with the margins.

Lines 107-120 LayoutUnit BlockFormattingContext::Geometry::MarginCollapse::computedNonCollapse a/Source/WebCore/layout/blockformatting/BlockMarginCollapse.cpp_sec1
- a/Source/WebCore/layout/blockformatting/BlockMarginCollapse.cpp -2 / +2 lines
107	{	107	{
108	ASSERT(layoutBox.isBlockLevelBox());	108	ASSERT(layoutBox.isBlockLevelBox());
109		109
110	return computedNonCollapsedVerticalMarginValue(layoutState, layoutBox).before;	110	return computedVerticalMargin(layoutState, layoutBox).before.valueOr(0);
111	}	111	}
112		112
113	LayoutUnit BlockFormattingContext::Geometry::MarginCollapse::computedNonCollapsedMarginAfter(const LayoutState& layoutState, const Box& layoutBox)	113	LayoutUnit BlockFormattingContext::Geometry::MarginCollapse::computedNonCollapsedMarginAfter(const LayoutState& layoutState, const Box& layoutBox)
114	{	114	{
115	ASSERT(layoutBox.isBlockLevelBox());	115	ASSERT(layoutBox.isBlockLevelBox());
116		116
117	return computedNonCollapsedVerticalMarginValue(layoutState, layoutBox).after;	117	return computedVerticalMargin(layoutState, layoutBox).after.valueOr(0);
118	}	118	}
119		119
120	LayoutUnit BlockFormattingContext::Geometry::MarginCollapse::nonCollapsedMarginBefore(const LayoutState& layoutState, const Box& layoutBox)	120	LayoutUnit BlockFormattingContext::Geometry::MarginCollapse::nonCollapsedMarginBefore(const LayoutState& layoutState, const Box& layoutBox)

Lines 193-206 Optional<Position> FloatingContext::verticalPositionWithClearance(const Box& lay a/Source/WebCore/layout/floats/FloatingContext.cpp_sec1
- a/Source/WebCore/layout/floats/FloatingContext.cpp -4 / +4 lines
193		193
194	// Reset previous bottom and current top margins to non-collapsing.	194	// Reset previous bottom and current top margins to non-collapsing.
195	auto previousVerticalMargin = previousInFlowDisplayBox.verticalMargin();	195	auto previousVerticalMargin = previousInFlowDisplayBox.verticalMargin();
196	if (previousVerticalMargin.collapsedValues() && previousVerticalMargin.collapsedValues()->after) {	196	if (previousVerticalMargin.collapsedValues().after) {
197	previousVerticalMargin.setCollapsedValues({ previousVerticalMargin.collapsedValues()->before, { } });	197	previousVerticalMargin.setCollapsedValues({ previousVerticalMargin.collapsedValues().before, { } });
198	previousInFlowDisplayBox.setVerticalMargin(previousVerticalMargin);	198	previousInFlowDisplayBox.setVerticalMargin(previousVerticalMargin);
199	}	199	}
200	// FIXME: check if collapsing through has anything to do with this.	200	// FIXME: check if collapsing through has anything to do with this.
201	auto verticalMargin = displayBox.verticalMargin();	201	auto verticalMargin = displayBox.verticalMargin();
202	if (verticalMargin.collapsedValues() && verticalMargin.collapsedValues()->before) {	202	if (verticalMargin.collapsedValues().before) {
203	verticalMargin.setCollapsedValues({ { }, verticalMargin.collapsedValues()->after });	203	verticalMargin.setCollapsedValues({ { }, verticalMargin.collapsedValues().after });
204	displayBox.setVerticalMargin(verticalMargin);	204	displayBox.setVerticalMargin(verticalMargin);
205	}	205	}
206		206