Changeset 239205 in webkit


Ignore:
Timestamp:
Dec 14, 2018 7:22:02 AM (5 years ago)
Author:
Alan Bujtas
Message:

[LFC][BFC] Introduce VerticalMargin and HorizontalMargin types.
​https://bugs.webkit.org/show_bug.cgi?id=192692

Reviewed by Antti Koivisto.

This is in preparation for completing block margin collapsing.

  • WebCore.xcodeproj/project.pbxproj:
  • 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::computedNonCollapsedHorizontalMarginValue):
(WebCore::Layout::FormattingContext::Geometry::computedNonCollapsedVerticalMarginValue):

  • layout/LayoutState.cpp:

(WebCore::Layout::LayoutState::LayoutState):

  • layout/LayoutUnits.h:

(WebCore::Layout::HeightAndMargin::usedMarginValues const): Deleted.

  • layout/MarginTypes.h: Added.

(WebCore::Layout::VerticalMargin::nonCollapsedValues const):
(WebCore::Layout::VerticalMargin::collapsedValues const):
(WebCore::Layout::VerticalMargin::setCollapsedValues):
(WebCore::Layout::VerticalMargin::VerticalMargin):
(WebCore::Layout::VerticalMargin::usedValues const):

  • 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/displaytree/DisplayBox.cpp:

(WebCore::Display::Box::Box):

  • layout/displaytree/DisplayBox.h:

(WebCore::Display::Box::setHorizontalMargin):
(WebCore::Display::Box::setVerticalMargin):
(WebCore::Display::Box::setHorizontalNonComputedMargin):
(WebCore::Display::Box::verticalMargin const):
(WebCore::Display::Box::marginTop const):
(WebCore::Display::Box::marginLeft const):
(WebCore::Display::Box::marginBottom const):
(WebCore::Display::Box::marginRight const):
(WebCore::Display::Box::nonCollapsedMarginTop const):
(WebCore::Display::Box::nonCollapsedMarginBottom const):
(WebCore::Display::Box::setVerticalNonCollapsedMargin): Deleted.

  • layout/floats/FloatingContext.cpp:

(WebCore::Layout::FloatingContext::verticalPositionWithClearance const):

  • layout/inlineformatting/InlineFormattingContext.cpp:

(WebCore::Layout::InlineFormattingContext::computeHeightAndMargin const):

Location:
trunk/Source/WebCore
Files:
1 added
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r239201 r239205  
     12018-12-14  Zalan Bujtas  <zalan@apple.com>
     2
     3        [LFC][BFC] Introduce VerticalMargin and HorizontalMargin types.
     4        https://bugs.webkit.org/show_bug.cgi?id=192692
     5
     6        Reviewed by Antti Koivisto.
     7
     8        This is in preparation for completing block margin collapsing.
     9
     10        * WebCore.xcodeproj/project.pbxproj:
     11        * layout/FormattingContext.cpp:
     12        (WebCore::Layout::FormattingContext::computeOutOfFlowVerticalGeometry const):
     13        * layout/FormattingContext.h:
     14        * layout/FormattingContextGeometry.cpp:
     15        (WebCore::Layout::FormattingContext::Geometry::outOfFlowNonReplacedVerticalGeometry):
     16        (WebCore::Layout::FormattingContext::Geometry::outOfFlowReplacedVerticalGeometry):
     17        (WebCore::Layout::FormattingContext::Geometry::complicatedCases):
     18        (WebCore::Layout::FormattingContext::Geometry::inlineReplacedHeightAndMargin):
     19        (WebCore::Layout::FormattingContext::Geometry::computedNonCollapsedHorizontalMarginValue):
     20        (WebCore::Layout::FormattingContext::Geometry::computedNonCollapsedVerticalMarginValue):
     21        * layout/LayoutState.cpp:
     22        (WebCore::Layout::LayoutState::LayoutState):
     23        * layout/LayoutUnits.h:
     24        (WebCore::Layout::HeightAndMargin::usedMarginValues const): Deleted.
     25        * layout/MarginTypes.h: Added.
     26        (WebCore::Layout::VerticalMargin::nonCollapsedValues const):
     27        (WebCore::Layout::VerticalMargin::collapsedValues const):
     28        (WebCore::Layout::VerticalMargin::setCollapsedValues):
     29        (WebCore::Layout::VerticalMargin::VerticalMargin):
     30        (WebCore::Layout::VerticalMargin::usedValues const):
     31        * layout/blockformatting/BlockFormattingContext.cpp:
     32        (WebCore::Layout::BlockFormattingContext::computeHeightAndMargin const):
     33        * layout/blockformatting/BlockFormattingContextGeometry.cpp:
     34        (WebCore::Layout::BlockFormattingContext::Geometry::inFlowNonReplacedHeightAndMargin):
     35        (WebCore::Layout::BlockFormattingContext::Geometry::inFlowHeightAndMargin):
     36        * layout/blockformatting/BlockFormattingContextQuirks.cpp:
     37        (WebCore::Layout::BlockFormattingContext::Quirks::stretchedHeight):
     38        * layout/displaytree/DisplayBox.cpp:
     39        (WebCore::Display::Box::Box):
     40        * layout/displaytree/DisplayBox.h:
     41        (WebCore::Display::Box::setHorizontalMargin):
     42        (WebCore::Display::Box::setVerticalMargin):
     43        (WebCore::Display::Box::setHorizontalNonComputedMargin):
     44        (WebCore::Display::Box::verticalMargin const):
     45        (WebCore::Display::Box::marginTop const):
     46        (WebCore::Display::Box::marginLeft const):
     47        (WebCore::Display::Box::marginBottom const):
     48        (WebCore::Display::Box::marginRight const):
     49        (WebCore::Display::Box::nonCollapsedMarginTop const):
     50        (WebCore::Display::Box::nonCollapsedMarginBottom const):
     51        (WebCore::Display::Box::setVerticalNonCollapsedMargin): Deleted.
     52        * layout/floats/FloatingContext.cpp:
     53        (WebCore::Layout::FloatingContext::verticalPositionWithClearance const):
     54        * layout/inlineformatting/InlineFormattingContext.cpp:
     55        (WebCore::Layout::InlineFormattingContext::computeHeightAndMargin const):
     56
    1572018-12-14  Fujii Hironori  <Hironori.Fujii@sony.com>
    258

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r239145 r239205  
    91509150                6FE198132178397B00446F08 /* InlineLineBreaker.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = InlineLineBreaker.cpp; sourceTree = "<group>"; };
    91519151                6FE198152178397C00446F08 /* InlineLineBreaker.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InlineLineBreaker.h; sourceTree = "<group>"; };
     9152                6FE7AA2621C37B6300296DCD /* MarginTypes.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = MarginTypes.h; sourceTree = "<group>"; };
    91529153                6FE7CFA02177EEF1005B1573 /* InlineItem.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InlineItem.h; sourceTree = "<group>"; };
    91539154                6FE7CFA32177EF10005B1573 /* LayoutLineBreakBox.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LayoutLineBreakBox.h; sourceTree = "<group>"; };
    … …  
    1613616137                                6F7CA3C4208C2956002F29AB /* LayoutState.h */,
    1613716138                                6F73918C2106CEDD006AF262 /* LayoutUnits.h */,
     16139                                6FE7AA2621C37B6300296DCD /* MarginTypes.h */,
    1613816140                                11FF02D520BA3C810083F25B /* Verification.cpp */,
    1613916141                        );
    … …  
    2555025552                                D0D8648221B61727003C983C /* WebGPUBufferDescriptor.h */,
    2555125553                                D0D8648321B61727003C983C /* WebGPUBufferDescriptor.idl */,
    25552                                 D063AE4E21C0810A000E6A35 /* WebGPUBufferUsage.h */,
    2555325554                                D063AE3F21C05DDD000E6A35 /* WebGPUBufferUsage.h */,
    25554                                 D063AE4C21C07AB5000E6A35 /* WebGPUBufferUsage.idl */,
    2555525555                                D063AE4021C05DDD000E6A35 /* WebGPUBufferUsage.idl */,
    2555625556                                D001D9AC21B0C81A0023B9BC /* WebGPUColor.h */,

  • trunk/Source/WebCore/layout/FormattingContext.cpp

    r238995 r239205  
    117117    auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
    118118    // Margins of absolutely positioned boxes do not collapse
    119     ASSERT(!verticalGeometry.heightAndMargin.collapsedMargin);
    120     auto nonCollapsedVerticalMargins = verticalGeometry.heightAndMargin.usedMarginValues();
     119    ASSERT(!verticalGeometry.heightAndMargin.margin.collapsedValues());
     120    auto nonCollapsedVerticalMargins = verticalGeometry.heightAndMargin.margin.nonCollapsedValues();
    121121    displayBox.setTop(verticalGeometry.top + nonCollapsedVerticalMargins.top);
    122122    displayBox.setContentBoxHeight(verticalGeometry.heightAndMargin.height);
    123     displayBox.setVerticalMargin(nonCollapsedVerticalMargins);
    124     displayBox.setVerticalNonCollapsedMargin(nonCollapsedVerticalMargins);
     123    displayBox.setVerticalMargin(verticalGeometry.heightAndMargin.margin);
    125124}
    126125

  • trunk/Source/WebCore/layout/FormattingContext.h

    r238667 r239205  
    9797        static std::optional<Edges> computedPadding(const LayoutState&, const Box&);
    9898
    99         static HorizontalEdges computedNonCollapsedHorizontalMarginValue(const LayoutState&, const Box&);
    100         static VerticalEdges computedNonCollapsedVerticalMarginValue(const LayoutState&, const Box&);
     99        static HorizontalMargin computedNonCollapsedHorizontalMarginValue(const LayoutState&, const Box&);
     100        static VerticalMargin::ComputedValues computedNonCollapsedVerticalMarginValue(const LayoutState&, const Box&);
    101101
    102102        static std::optional<LayoutUnit> computedValueIfNotAuto(const Length& geometryProperty, LayoutUnit containingBlockWidth);

  • trunk/Source/WebCore/layout/FormattingContextGeometry.cpp

    r238961 r239205  
    357357
    358358    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Position][Height][Margin] -> out-of-flow non-replaced -> top(" << *top << "px) bottom("  << *bottom << "px) height(" << *height << "px) margin(" << *marginTop << "px, "  << *marginBottom << "px) layoutBox(" << &layoutBox << ")");
    359     return { *top, *bottom, { *height, { *marginTop, *marginBottom }, { } } };
     359    return { *top, *bottom, { *height, { { *marginTop, *marginBottom }, { } } } };
    360360}
    361361
    … …  
    572572
    573573    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Position][Height][Margin] -> out-of-flow replaced -> top(" << *top << "px) bottom("  << *bottom << "px) height(" << height << "px) margin(" << *marginTop << "px, "  << *marginBottom << "px) layoutBox(" << &layoutBox << ")");
    574     return { *top, *bottom, { height, { *marginTop, *marginBottom }, { } } };
     574    return { *top, *bottom, { height, { { *marginTop, *marginBottom }, { } } } };
    575575}
    576576
    … …  
    711711
    712712    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> floating non-replaced -> height(" << *height << "px) margin(" << *marginTop << "px, " << *marginBottom << "px) -> layoutBox(" << &layoutBox << ")");
    713     return HeightAndMargin { *height, { *marginTop, *marginBottom }, { } };
     713    return HeightAndMargin { *height, { { *marginTop, *marginBottom }, { } } };
    714714}
    715715
    … …  
    839839
    840840    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> inflow replaced -> height(" << *height << "px) margin(" << margin.top << "px, " << margin.bottom << "px) -> layoutBox(" << &layoutBox << ")");
    841     return { *height, margin, { } };
     841    return { *height, { margin, { } } };
    842842}
    843843
    … …  
    10211021}
    10221022
    1023 HorizontalEdges FormattingContext::Geometry::computedNonCollapsedHorizontalMarginValue(const LayoutState& layoutState, const Box& layoutBox)
     1023HorizontalMargin FormattingContext::Geometry::computedNonCollapsedHorizontalMarginValue(const LayoutState& layoutState, const Box& layoutBox)
    10241024{
    10251025    auto& style = layoutBox.style();
    … …  
    10331033}
    10341034
    1035 VerticalEdges FormattingContext::Geometry::computedNonCollapsedVerticalMarginValue(const LayoutState& layoutState, const Box& layoutBox)
     1035VerticalMargin::ComputedValues FormattingContext::Geometry::computedNonCollapsedVerticalMarginValue(const LayoutState& layoutState, const Box& layoutBox)
    10361036{
    10371037    auto& style = layoutBox.style();

  • trunk/Source/WebCore/layout/LayoutState.cpp

    r238995 r239205  
    5757    displayBox.setHorizontalNonComputedMargin({ });
    5858    displayBox.setVerticalMargin({ });
    59     displayBox.setVerticalNonCollapsedMargin({ });
    6059    displayBox.setBorder({ });
    6160    displayBox.setPadding({ });

  • trunk/Source/WebCore/layout/LayoutUnits.h

    r238931 r239205  
    3131#include "LayoutPoint.h"
    3232#include "LayoutRect.h"
     33#include "MarginTypes.h"
    3334#include <wtf/Optional.h>
    3435
    … …  
    103104struct WidthAndMargin {
    104105    LayoutUnit width;
    105     HorizontalEdges margin;
    106     HorizontalEdges nonComputedMargin;
     106    HorizontalMargin margin;
     107    // FIXME: Figure out if we really really need this.
     108    HorizontalMargin nonComputedMargin;
    107109};
    108110
    109111struct HeightAndMargin {
    110     VerticalEdges usedMarginValues() const { return collapsedMargin.value_or(nonCollapsedMargin); }
    111 
    112112    LayoutUnit height;
    113     VerticalEdges nonCollapsedMargin;
    114     std::optional<VerticalEdges> collapsedMargin;
     113    VerticalMargin margin;
    115114};
    116115

  • trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp

    r238995 r239205  
    359359            // Used height should remain the same.
    360360            ASSERT((layoutState.inQuirksMode() && (layoutBox.isBodyBox() || layoutBox.isDocumentBox())) || maxHeightAndMargin.height == *maxHeight);
    361             heightAndMargin = { *maxHeight, maxHeightAndMargin.nonCollapsedMargin, maxHeightAndMargin.collapsedMargin };
     361            heightAndMargin = { *maxHeight, maxHeightAndMargin.margin };
    362362        }
    363363    }
    … …  
    368368            // Used height should remain the same.
    369369            ASSERT((layoutState.inQuirksMode() && (layoutBox.isBodyBox() || layoutBox.isDocumentBox())) || minHeightAndMargin.height == *minHeight);
    370             heightAndMargin = { *minHeight, minHeightAndMargin.nonCollapsedMargin, minHeightAndMargin.collapsedMargin };
     370            heightAndMargin = { *minHeight, minHeightAndMargin.margin };
    371371        }
    372372    }
    … …  
    374374    auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
    375375    displayBox.setContentBoxHeight(heightAndMargin.height);
    376     displayBox.setVerticalNonCollapsedMargin(heightAndMargin.nonCollapsedMargin);
    377     displayBox.setVerticalMargin(heightAndMargin.usedMarginValues());
     376    displayBox.setVerticalMargin(heightAndMargin.margin);
    378377
    379378    // If this box has already been moved by the estimated vertical margin, no need to move it again.
    380379    if (layoutBox.isFloatingPositioned() || !displayBox.estimatedMarginTop())
    381         displayBox.moveVertically(heightAndMargin.usedMarginValues().top);
     380        displayBox.moveVertically(heightAndMargin.margin.usedValues().top);
    382381}
    383382

  • trunk/Source/WebCore/layout/blockformatting/BlockFormattingContextGeometry.cpp

    r238931 r239205  
    6262        auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
    6363
    64         VerticalEdges nonCollapsedMargin = { computedValueIfNotAuto(style.marginTop(), containingBlockWidth).value_or(0),
     64        auto nonCollapsedMargin = VerticalMargin::ComputedValues { computedValueIfNotAuto(style.marginTop(), containingBlockWidth).value_or(0),
    6565            computedValueIfNotAuto(style.marginBottom(), containingBlockWidth).value_or(0) };
    66         VerticalEdges collapsedMargin = { MarginCollapse::marginTop(layoutState, layoutBox), MarginCollapse::marginBottom(layoutState, layoutBox) };
     66        auto collapsedMargin = VerticalMargin::CollapsedValues { MarginCollapse::marginTop(layoutState, layoutBox), MarginCollapse::marginBottom(layoutState, layoutBox) };
    6767        auto borderAndPaddingTop = displayBox.borderTop() + displayBox.paddingTop().value_or(0);
    68        
     68
    6969        auto height = usedHeight ? usedHeight.value() : computedHeightValue(layoutState, layoutBox, HeightType::Normal);
    7070        if (height)
    71             return { height.value(), nonCollapsedMargin, collapsedMargin };
     71            return { height.value(), { nonCollapsedMargin, collapsedMargin } };
    7272
    7373        if (!is<Container>(layoutBox) || !downcast<Container>(layoutBox).hasInFlowChild())
    74             return { 0, nonCollapsedMargin, collapsedMargin };
     74            return { 0, { nonCollapsedMargin, collapsedMargin } };
    7575
    7676        // 1. the bottom edge of the last line box, if the box establishes a inline formatting context with one or more lines
    … …  
    7979            auto& inlineRuns = downcast<InlineFormattingState>(layoutState.establishedFormattingState(layoutBox)).inlineRuns();
    8080            auto bottomEdge = inlineRuns.isEmpty() ? LayoutUnit() : inlineRuns.last().logicalBottom();
    81             return { bottomEdge, nonCollapsedMargin, collapsedMargin };
     81            return { bottomEdge, { nonCollapsedMargin, collapsedMargin } };
    8282        }
    8383
    … …  
    8787        if (!MarginCollapse::isMarginBottomCollapsedWithParent(*lastInFlowChild)) {
    8888            auto& lastInFlowDisplayBox = layoutState.displayBoxForLayoutBox(*lastInFlowChild);
    89             return { lastInFlowDisplayBox.bottom() + lastInFlowDisplayBox.marginBottom() - borderAndPaddingTop, nonCollapsedMargin, collapsedMargin };
     89            return { lastInFlowDisplayBox.bottom() + lastInFlowDisplayBox.marginBottom() - borderAndPaddingTop, { nonCollapsedMargin, collapsedMargin } };
    9090        }
    9191
    … …  
    9696        if (inFlowChild) {
    9797            auto& inFlowDisplayBox = layoutState.displayBoxForLayoutBox(*inFlowChild);
    98             return { inFlowDisplayBox.top() + inFlowDisplayBox.borderBox().height() - borderAndPaddingTop, nonCollapsedMargin, collapsedMargin };
     98            return { inFlowDisplayBox.top() + inFlowDisplayBox.borderBox().height() - borderAndPaddingTop, { nonCollapsedMargin, collapsedMargin } };
    9999        }
    100100
    101101        // 4. zero, otherwise
    102         return { 0, nonCollapsedMargin, collapsedMargin };
     102        return { 0, { nonCollapsedMargin, collapsedMargin } };
    103103    };
    104104
    105105    auto heightAndMargin = compute();
    106106
    107     LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> inflow non-replaced -> height(" << heightAndMargin.height << "px) margin(" << heightAndMargin.usedMarginValues().top << "px, " << heightAndMargin.usedMarginValues().bottom << "px) -> layoutBox(" << &layoutBox << ")");
     107    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> inflow non-replaced -> height(" << heightAndMargin.height << "px) margin(" << heightAndMargin.margin.usedValues().top << "px, " << heightAndMargin.margin.usedValues().bottom << "px) -> layoutBox(" << &layoutBox << ")");
    108108    return heightAndMargin;
    109109}
    … …  
    264264    heightAndMargin = Quirks::stretchedHeight(layoutState, layoutBox, heightAndMargin);
    265265
    266     LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> inflow non-replaced -> streched to viewport -> height(" << heightAndMargin.height << "px) margin(" << heightAndMargin.usedMarginValues().top << "px, " << heightAndMargin.usedMarginValues().bottom << "px) -> layoutBox(" << &layoutBox << ")");
     266    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> inflow non-replaced -> streched to viewport -> height(" << heightAndMargin.height << "px) margin(" << heightAndMargin.margin.usedValues().top << "px, " << heightAndMargin.margin.usedValues().bottom << "px) -> layoutBox(" << &layoutBox << ")");
    267267    return heightAndMargin;
    268268}

  • trunk/Source/WebCore/layout/blockformatting/BlockFormattingContextQuirks.cpp

    r238995 r239205  
    8181    LayoutUnit totalVerticalMargins;
    8282    if (layoutBox.isDocumentBox()) {
    83         auto verticalMargins = heightAndMargin.usedMarginValues();
     83        auto verticalMargins = heightAndMargin.margin.usedValues();
    8484        // Document box's margins do not collapse.
    85         ASSERT(!heightAndMargin.collapsedMargin);
     85        ASSERT(!heightAndMargin.margin.collapsedValues());
    8686        totalVerticalMargins = verticalMargins.top + verticalMargins.bottom;
    8787    } else if (layoutBox.isBodyBox()) {
    … …  
    9494        // This quirk happens when the body height is 0 which means its vertical margins collapse through (top and bottom margins are adjoining).
    9595        // 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 bodyBoxVerticalMargins = heightAndMargin.height ? heightAndMargin.usedMarginValues() : heightAndMargin.nonCollapsedMargin;
     96        auto bodyBoxVerticalMargins = heightAndMargin.height ? heightAndMargin.margin.usedValues() : heightAndMargin.margin.nonCollapsedValues();
    9797        totalVerticalMargins = bodyBoxVerticalMargins.top + bodyBoxVerticalMargins.bottom;
    9898    }

  • trunk/Source/WebCore/layout/displaytree/DisplayBox.cpp

    r235501 r239205  
    5858    , m_contentWidth(other.m_contentWidth)
    5959    , m_contentHeight(other.m_contentHeight)
    60     , m_margin(other.m_margin)
    61     , m_verticalNonCollapsedMargin(other.m_verticalNonCollapsedMargin)
     60    , m_horizontalMargin(other.m_horizontalMargin)
     61    , m_verticalMargin(other.m_verticalMargin)
    6262    , m_horizontalNonComputedMargin(other.m_horizontalNonComputedMargin)
    6363    , m_estimatedMarginTop(other.m_estimatedMarginTop)

  • trunk/Source/WebCore/layout/displaytree/DisplayBox.h

    r237631 r239205  
    139139    Rect rectWithMargin() const { return { top() - marginTop(), left() - marginLeft(), marginLeft() + width() + marginRight(), marginTop() + height() + marginBottom() }; }
    140140
     141    Layout::VerticalMargin verticalMargin() const;
    141142    LayoutUnit marginTop() const;
    142143    LayoutUnit marginLeft() const;
    … …  
    191192    void setContentBoxWidth(LayoutUnit);
    192193
    193     void setHorizontalMargin(Layout::HorizontalEdges);
    194     void setVerticalMargin(Layout::VerticalEdges);
    195     void setVerticalNonCollapsedMargin(Layout::VerticalEdges);
    196     void setHorizontalNonComputedMargin(Layout::HorizontalEdges);
     194    void setHorizontalMargin(Layout::HorizontalMargin);
     195    void setVerticalMargin(Layout::VerticalMargin);
     196    void setHorizontalNonComputedMargin(Layout::HorizontalMargin);
    197197    void setEstimatedMarginTop(LayoutUnit marginTop) { m_estimatedMarginTop = marginTop; }
    198198
    … …  
    225225    LayoutUnit m_contentHeight;
    226226
    227     Layout::Edges m_margin;
    228     Layout::VerticalEdges m_verticalNonCollapsedMargin;
    229     Layout::HorizontalEdges m_horizontalNonComputedMargin;
     227    Layout::HorizontalMargin m_horizontalMargin;
     228    Layout::VerticalMargin m_verticalMargin;
     229    Layout::HorizontalMargin m_horizontalNonComputedMargin;
    230230    std::optional<LayoutUnit> m_estimatedMarginTop;
    231231
    … …  
    508508}
    509509
    510 inline void Box::setHorizontalMargin(Layout::HorizontalEdges margin)
     510inline void Box::setHorizontalMargin(Layout::HorizontalMargin margin)
    511511{
    512512#if !ASSERT_DISABLED
    513513    setHasValidHorizontalMargin();
    514514#endif
    515     m_margin.horizontal = margin;
    516 }
    517 
    518 inline void Box::setVerticalMargin(Layout::VerticalEdges margin)
     515    m_horizontalMargin = margin;
     516}
     517
     518inline void Box::setVerticalMargin(Layout::VerticalMargin margin)
    519519{
    520520#if !ASSERT_DISABLED
    521521    setHasValidVerticalMargin();
    522 #endif
    523     ASSERT(!m_estimatedMarginTop || *m_estimatedMarginTop == margin.top);
    524     m_margin.vertical = margin;
    525 }
    526 
    527 inline void Box::setVerticalNonCollapsedMargin(Layout::VerticalEdges margin)
    528 {
    529 #if !ASSERT_DISABLED
    530522    setHasValidVerticalNonCollapsedMargin();
    531523#endif
    532     m_verticalNonCollapsedMargin = margin;
    533 }
    534 
    535 inline void Box::setHorizontalNonComputedMargin(Layout::HorizontalEdges margin)
     524    ASSERT(!m_estimatedMarginTop || *m_estimatedMarginTop == margin.usedValues().top);
     525    m_verticalMargin = margin;
     526}
     527
     528inline void Box::setHorizontalNonComputedMargin(Layout::HorizontalMargin margin)
    536529{
    537530#if !ASSERT_DISABLED
    … …  
    557550}
    558551
     552inline Layout::VerticalMargin Box::verticalMargin() const
     553{
     554    ASSERT(m_hasValidVerticalMargin);
     555    return m_verticalMargin;
     556}
     557
    559558inline LayoutUnit Box::marginTop() const
    560559{
    561560    ASSERT(m_hasValidVerticalMargin);
    562     return m_margin.vertical.top;
     561    return m_verticalMargin.usedValues().top;
    563562}
    564563
    … …  
    566565{
    567566    ASSERT(m_hasValidHorizontalMargin);
    568     return m_margin.horizontal.left;
     567    return m_horizontalMargin.left;
    569568}
    570569
    … …  
    572571{
    573572    ASSERT(m_hasValidVerticalMargin);
    574     return m_margin.vertical.bottom;
     573    return m_verticalMargin.usedValues().bottom;
    575574}
    576575
    … …  
    578577{
    579578    ASSERT(m_hasValidHorizontalMargin);
    580     return m_margin.horizontal.right;
     579    return m_horizontalMargin.right;
    581580}
    582581
    … …  
    584583{
    585584    ASSERT(m_hasValidVerticalNonCollapsedMargin);
    586     return m_verticalNonCollapsedMargin.top;
     585    return m_verticalMargin.nonCollapsedValues().top;
    587586}
    588587
    … …  
    590589{
    591590    ASSERT(m_hasValidVerticalNonCollapsedMargin);
    592     return m_verticalNonCollapsedMargin.bottom;
     591    return m_verticalMargin.nonCollapsedValues().bottom;
    593592}
    594593

  • trunk/Source/WebCore/layout/floats/FloatingContext.cpp

    r238995 r239205  
    193193
    194194            // Reset previous bottom and current top margins to non-collapsing.
    195             previousInFlowDisplayBox.setVerticalMargin({ previousInFlowDisplayBox.marginTop(), previousInFlowDisplayBox.nonCollapsedMarginBottom() });
    196             displayBox.setVerticalMargin({ displayBox.nonCollapsedMarginTop(), displayBox.marginBottom() });
     195            auto previousVerticalMargin = previousInFlowDisplayBox.verticalMargin();
     196            if (previousVerticalMargin.collapsedValues() && previousVerticalMargin.collapsedValues()->bottom) {
     197                previousVerticalMargin.setCollapsedValues({ previousVerticalMargin.collapsedValues()->top, { } });
     198                previousInFlowDisplayBox.setVerticalMargin(previousVerticalMargin);
     199            }
     200            // FIXME: check if collapsing through has anything to do with this.
     201            auto verticalMargin = displayBox.verticalMargin();
     202            if (verticalMargin.collapsedValues() && verticalMargin.collapsedValues()->top) {
     203                verticalMargin.setCollapsedValues({ { }, verticalMargin.collapsedValues()->bottom });
     204                displayBox.setVerticalMargin(verticalMargin);
     205            }
    197206
    198207            auto nonCollapsedMargin = previousInFlowDisplayBox.marginBottom() + displayBox.marginTop();

  • trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp

    r238995 r239205  
    363363    auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
    364364    displayBox.setContentBoxHeight(heightAndMargin.height);
    365     displayBox.setVerticalNonCollapsedMargin(heightAndMargin.nonCollapsedMargin);
    366     displayBox.setVerticalMargin(heightAndMargin.usedMarginValues());
     365    displayBox.setVerticalMargin(heightAndMargin.margin);
    367366}
    368367
Note: See TracChangeset for help on using the changeset viewer.