Attachment 358258 Details for Bug 193059 – Patch

[patch] Patch

bug-193059-20190103101003.patch (text/plain), 57.33 KB, created by zalan on 2019-01-03 10:10:08 PST

(hide)

Description:

Filename:

MIME Type:

Creator: zalan

Created: 2019-01-03 10:10:08 PST

Size: 57.33 KB

patch

obsolete

>Subversion Revision: 239591
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index dc1f8d982cc8394940734728052ad8004df6fa69..6d35ccafa54c8b43b8100dfb924ee460656e8ef6 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,55 @@
>+2019-01-03  Zalan Bujtas  <zalan@apple.com>
>+
>+        [LFC][BFC] Use computedValue and usedValue consistently
>+        https://bugs.webkit.org/show_bug.cgi?id=193059
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        https://www.w3.org/TR/CSS22/cascade.html#value-stages
>+
>+        6.1.2 Computed values
>+        Specified values are resolved to computed values during the cascade; for example URIs are made absolute and 'em' and 'ex' units
>+        are computed to pixel or absolute lengths. Computing a value never requires the user agent to render the document...
>+
>+        6.1.3 Used values
>+        Computed values are processed as far as possible without formatting the document. Some values, however, can only be determined when the document
>+        is being laid out. For example, if the width of an element is set to be a certain percentage of its containing block, the width cannot be determined until the width of the containing block has been determined. The used value is the result of taking the computed value and resolving any remaining dependencies into an absolute value.
>+
>+        * layout/FormattingContext.cpp:
>+        (WebCore::Layout::FormattingContext::computeOutOfFlowHorizontalGeometry const):
>+        * layout/FormattingContextGeometry.cpp:
>+        (WebCore::Layout::FormattingContext::Geometry::outOfFlowNonReplacedHorizontalGeometry):
>+        (WebCore::Layout::FormattingContext::Geometry::outOfFlowReplacedVerticalGeometry):
>+        (WebCore::Layout::FormattingContext::Geometry::outOfFlowReplacedHorizontalGeometry):
>+        (WebCore::Layout::FormattingContext::Geometry::complicatedCases):
>+        (WebCore::Layout::FormattingContext::Geometry::inlineReplacedWidthAndMargin):
>+        * layout/LayoutState.cpp:
>+        (WebCore::Layout::LayoutState::LayoutState):
>+        * layout/LayoutUnits.h:
>+        * layout/Verification.cpp:
>+        (WebCore::Layout::outputMismatchingBlockBoxInformationIfNeeded):
>+        * layout/blockformatting/BlockFormattingContext.cpp:
>+        (WebCore::Layout::BlockFormattingContext::computeWidthAndMargin const):
>+        * layout/blockformatting/BlockFormattingContextGeometry.cpp:
>+        (WebCore::Layout::BlockFormattingContext::Geometry::inFlowNonReplacedWidthAndMargin):
>+        (WebCore::Layout::BlockFormattingContext::Geometry::inFlowReplacedWidthAndMargin):
>+        * layout/displaytree/DisplayBox.cpp:
>+        (WebCore::Display::Box::Box):
>+        * layout/displaytree/DisplayBox.h:
>+        (WebCore::Display::Box::setHasValidHorizontalComputedMargin):
>+        (WebCore::Display::Box::setHorizontalComputedMargin):
>+        (WebCore::Display::Box::computedMarginStart const):
>+        (WebCore::Display::Box::computedMarginEnd const):
>+        (WebCore::Display::Box::setHasValidHorizontalNonComputedMargin): Deleted.
>+        (WebCore::Display::Box::setHorizontalNonComputedMargin): Deleted.
>+        (WebCore::Display::Box::nonComputedMarginStart const): Deleted.
>+        (WebCore::Display::Box::nonComputedMarginEnd const): Deleted.
>+        * layout/floats/FloatAvoider.h:
>+        (WebCore::Layout::FloatAvoider::marginStart const):
>+        (WebCore::Layout::FloatAvoider::marginEnd const):
>+        * layout/inlineformatting/InlineFormattingContext.cpp:
>+        (WebCore::Layout::InlineFormattingContext::computeWidthAndMargin const):
>+
> 2019-01-02  Simon Fraser  <simon.fraser@apple.com>
> 
>         REGRESSION (r239306): Don't disable font smoothing in transparent layers on macOS Mojave and later
>diff --git a/Source/WebCore/layout/FormattingContext.cpp b/Source/WebCore/layout/FormattingContext.cpp
>index 11efc4618b91aa8f61ff0325ca76480e48c95926..5e536a8bae7351c35d3a2fa438539c06745818ad 100644
>--- a/Source/WebCore/layout/FormattingContext.cpp
>+++ b/Source/WebCore/layout/FormattingContext.cpp
>@@ -87,10 +87,10 @@ void FormattingContext::computeOutOfFlowHorizontalGeometry(const Box& layoutBox)
>     }
> 
>     auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
>-    displayBox.setLeft(horizontalGeometry.left + horizontalGeometry.widthAndMargin.margin.start);
>+    displayBox.setLeft(horizontalGeometry.left + horizontalGeometry.widthAndMargin.usedMargin.start);
>     displayBox.setContentBoxWidth(horizontalGeometry.widthAndMargin.width);
>-    displayBox.setHorizontalMargin(horizontalGeometry.widthAndMargin.margin);
>-    displayBox.setHorizontalNonComputedMargin(horizontalGeometry.widthAndMargin.nonComputedMargin);
>+    displayBox.setHorizontalMargin(horizontalGeometry.widthAndMargin.usedMargin);
>+    displayBox.setHorizontalComputedMargin(horizontalGeometry.widthAndMargin.computedMargin);
> }
> 
> void FormattingContext::computeOutOfFlowVerticalGeometry(const Box& layoutBox) const
>diff --git a/Source/WebCore/layout/FormattingContextGeometry.cpp b/Source/WebCore/layout/FormattingContextGeometry.cpp
>index c339f9780fc40eff608f92579cc4700d911e4e3e..b4d8f4f54dc03869c19274f05d05e3eaa037ebd1 100644
>--- a/Source/WebCore/layout/FormattingContextGeometry.cpp
>+++ b/Source/WebCore/layout/FormattingContextGeometry.cpp
>@@ -280,8 +280,10 @@ VerticalGeometry FormattingContext::Geometry::outOfFlowNonReplacedVerticalGeomet
>     auto top = computedValueIfNotAuto(style.logicalTop(), containingBlockWidth);
>     auto bottom = computedValueIfNotAuto(style.logicalBottom(), containingBlockWidth);
>     auto height = usedHeight ? usedHeight.value() : computedHeightValue(layoutState, layoutBox, HeightType::Normal);
>-    auto marginBefore = computedValueIfNotAuto(style.marginBefore(), containingBlockWidth);
>-    auto marginAfter = computedValueIfNotAuto(style.marginAfter(), containingBlockWidth);
>+    auto computedMarginBefore = computedValueIfNotAuto(style.marginBefore(), containingBlockWidth);
>+    auto computedMarginAfter = computedValueIfNotAuto(style.marginAfter(), containingBlockWidth);
>+    auto usedMarginBefore = computedMarginBefore;
>+    auto usedMarginAfter = computedMarginAfter;
>     auto paddingTop = displayBox.paddingTop().valueOr(0);
>     auto paddingBottom = displayBox.paddingBottom().valueOr(0);
>     auto borderTop = displayBox.borderTop();
>@@ -291,72 +293,72 @@ VerticalGeometry FormattingContext::Geometry::outOfFlowNonReplacedVerticalGeomet
>         top = staticVerticalPositionForOutOfFlowPositioned(layoutState, layoutBox);
> 
>     if (top && height && bottom) {
>-        if (!marginBefore && !marginAfter) {
>+        if (!usedMarginBefore && !usedMarginAfter) {
>             auto marginBeforeAndAfter = containingBlockHeight - (*top + borderTop + paddingTop + *height + paddingBottom + borderBottom + *bottom);
>-            marginBefore = marginAfter = marginBeforeAndAfter / 2;
>-        } else if (!marginBefore)
>-            marginBefore = containingBlockHeight - (*top + borderTop + paddingTop + *height + paddingBottom + borderBottom + *marginAfter + *bottom);
>+            usedMarginBefore = usedMarginAfter = marginBeforeAndAfter / 2;
>+        } else if (!usedMarginBefore)
>+            usedMarginBefore = containingBlockHeight - (*top + borderTop + paddingTop + *height + paddingBottom + borderBottom + *usedMarginAfter + *bottom);
>         else
>-            marginAfter = containingBlockHeight - (*top + *marginBefore + borderTop + paddingTop + *height + paddingBottom + borderBottom + *bottom);
>+            usedMarginAfter = containingBlockHeight - (*top + *usedMarginBefore + borderTop + paddingTop + *height + paddingBottom + borderBottom + *bottom);
>         // Over-constrained?
>-        auto boxHeight = *top + *marginBefore + borderTop + paddingTop + *height + paddingBottom + borderBottom + *marginAfter + *bottom;
>+        auto boxHeight = *top + *usedMarginBefore + borderTop + paddingTop + *height + paddingBottom + borderBottom + *usedMarginAfter + *bottom;
>         if (boxHeight > containingBlockHeight)
>-            bottom = containingBlockHeight - (*top + *marginBefore + borderTop + paddingTop + *height + paddingBottom + borderBottom + *marginAfter); 
>+            bottom = containingBlockHeight - (*top + *usedMarginBefore + borderTop + paddingTop + *height + paddingBottom + borderBottom + *usedMarginAfter); 
>     }
> 
>     if (!top && !height && bottom) {
>         // #1
>         height = contentHeightForFormattingContextRoot(layoutState, layoutBox);
>-        marginBefore = marginBefore.valueOr(0);
>-        marginAfter = marginAfter.valueOr(0);
>-        top = containingBlockHeight - (*marginBefore + borderTop + paddingTop + *height + paddingBottom + borderBottom + *marginAfter + *bottom); 
>+        usedMarginBefore = usedMarginBefore.valueOr(0);
>+        usedMarginAfter = usedMarginAfter.valueOr(0);
>+        top = containingBlockHeight - (*usedMarginBefore + borderTop + paddingTop + *height + paddingBottom + borderBottom + *usedMarginAfter + *bottom); 
>     }
> 
>     if (!top && !bottom && height) {
>         // #2
>         top = staticVerticalPositionForOutOfFlowPositioned(layoutState, layoutBox);
>-        marginBefore = marginBefore.valueOr(0);
>-        marginAfter = marginAfter.valueOr(0);
>-        bottom = containingBlockHeight - (*top + *marginBefore + borderTop + paddingTop + *height + paddingBottom + borderBottom + *marginAfter); 
>+        usedMarginBefore = usedMarginBefore.valueOr(0);
>+        usedMarginAfter = usedMarginAfter.valueOr(0);
>+        bottom = containingBlockHeight - (*top + *usedMarginBefore + borderTop + paddingTop + *height + paddingBottom + borderBottom + *usedMarginAfter); 
>     }
> 
>     if (!height && !bottom && top) {
>         // #3
>         height = contentHeightForFormattingContextRoot(layoutState, layoutBox);
>-        marginBefore = marginBefore.valueOr(0);
>-        marginAfter = marginAfter.valueOr(0);
>-        bottom = containingBlockHeight - (*top + *marginBefore + borderTop + paddingTop + *height + paddingBottom + borderBottom + *marginAfter); 
>+        usedMarginBefore = usedMarginBefore.valueOr(0);
>+        usedMarginAfter = usedMarginAfter.valueOr(0);
>+        bottom = containingBlockHeight - (*top + *usedMarginBefore + borderTop + paddingTop + *height + paddingBottom + borderBottom + *usedMarginAfter); 
>     }
> 
>     if (!top && height && bottom) {
>         // #4
>-        marginBefore = marginBefore.valueOr(0);
>-        marginAfter = marginAfter.valueOr(0);
>-        top = containingBlockHeight - (*marginBefore + borderTop + paddingTop + *height + paddingBottom + borderBottom + *marginAfter + *bottom); 
>+        usedMarginBefore = usedMarginBefore.valueOr(0);
>+        usedMarginAfter = usedMarginAfter.valueOr(0);
>+        top = containingBlockHeight - (*usedMarginBefore + borderTop + paddingTop + *height + paddingBottom + borderBottom + *usedMarginAfter + *bottom); 
>     }
> 
>     if (!height && top && bottom) {
>         // #5
>-        marginBefore = marginBefore.valueOr(0);
>-        marginAfter = marginAfter.valueOr(0);
>-        height = containingBlockHeight - (*top + *marginBefore + borderTop + paddingTop + paddingBottom + borderBottom + *marginAfter + *bottom); 
>+        usedMarginBefore = usedMarginBefore.valueOr(0);
>+        usedMarginAfter = usedMarginAfter.valueOr(0);
>+        height = containingBlockHeight - (*top + *usedMarginBefore + borderTop + paddingTop + paddingBottom + borderBottom + *usedMarginAfter + *bottom); 
>     }
> 
>     if (!bottom && top && height) {
>         // #6
>-        marginBefore = marginBefore.valueOr(0);
>-        marginAfter = marginAfter.valueOr(0);
>-        bottom = containingBlockHeight - (*top + *marginBefore + borderTop + paddingTop + *height + paddingBottom + borderBottom + *marginAfter); 
>+        usedMarginBefore = usedMarginBefore.valueOr(0);
>+        usedMarginAfter = usedMarginAfter.valueOr(0);
>+        bottom = containingBlockHeight - (*top + *usedMarginBefore + borderTop + paddingTop + *height + paddingBottom + borderBottom + *usedMarginAfter); 
>     }
> 
>     ASSERT(top);
>     ASSERT(bottom);
>     ASSERT(height);
>-    ASSERT(marginBefore);
>-    ASSERT(marginAfter);
>+    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(" << *marginBefore << "px, "  << *marginAfter << "px) layoutBox(" << &layoutBox << ")");
>-    return { *top, *bottom, { *height, { { *marginBefore, *marginAfter }, { } } } };
>+    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Position][Height][Margin] -> out-of-flow non-replaced -> top(" << *top << "px) bottom("  << *bottom << "px) height(" << *height << "px) margin(" << *usedMarginBefore << "px, "  << *usedMarginAfter << "px) layoutBox(" << &layoutBox << ")");
>+    return { *top, *bottom, { *height, { { *usedMarginBefore, *usedMarginAfter }, { } } } };
> }
> 
> HorizontalGeometry FormattingContext::Geometry::outOfFlowNonReplacedHorizontalGeometry(LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedWidth)
>@@ -398,10 +400,10 @@ HorizontalGeometry FormattingContext::Geometry::outOfFlowNonReplacedHorizontalGe
>     auto left = computedValueIfNotAuto(style.logicalLeft(), containingBlockWidth);
>     auto right = computedValueIfNotAuto(style.logicalRight(), containingBlockWidth);
>     auto width = computedValueIfNotAuto(usedWidth ? Length { usedWidth.value(), Fixed } : style.logicalWidth(), containingBlockWidth);
>-    auto marginStart = computedValueIfNotAuto(style.marginStart(), containingBlockWidth);
>-    auto marginEnd = computedValueIfNotAuto(style.marginEnd(), containingBlockWidth);
>-    auto nonComputedMarginStart = marginStart.valueOr(0);
>-    auto nonComputedMarginEnd = marginEnd.valueOr(0);
>+    auto computedMarginStart = computedValueIfNotAuto(style.marginStart(), containingBlockWidth);
>+    auto computedMarginEnd = computedValueIfNotAuto(style.marginEnd(), containingBlockWidth);
>+    auto usedMarginStart = computedMarginStart;
>+    auto usedMarginEnd = computedMarginEnd;
>     auto paddingLeft = displayBox.paddingLeft().valueOr(0);
>     auto paddingRight = displayBox.paddingRight().valueOr(0);
>     auto borderLeft = displayBox.borderLeft();
>@@ -411,8 +413,8 @@ HorizontalGeometry FormattingContext::Geometry::outOfFlowNonReplacedHorizontalGe
>         // If all three of 'left', 'width', and 'right' are 'auto': First set any 'auto' values for 'margin-left' and 'margin-right' to 0.
>         // Then, if the 'direction' property of the element establishing the static-position containing block is 'ltr' set 'left' to the static
>         // position and apply rule number three below; otherwise, set 'right' to the static position and apply rule number one below.
>-        marginStart = marginStart.valueOr(0);
>-        marginEnd = marginEnd.valueOr(0);
>+        usedMarginStart = usedMarginStart.valueOr(0);
>+        usedMarginEnd = usedMarginEnd.valueOr(0);
> 
>         auto staticHorizontalPosition = staticHorizontalPositionForOutOfFlowPositioned(layoutState, layoutBox);
>         if (isLeftToRightDirection)
>@@ -425,84 +427,84 @@ HorizontalGeometry FormattingContext::Geometry::outOfFlowNonReplacedHorizontalGe
>         // solve for 'margin-right' ('margin-left'). If one of 'margin-left' or 'margin-right' is 'auto', solve the equation for that value.
>         // If the values are over-constrained, ignore the value for 'left' (in case the 'direction' property of the containing block is 'rtl') or 'right'
>         // (in case 'direction' is 'ltr') and solve for that value.
>-        if (!marginStart && !marginEnd) {
>+        if (!usedMarginStart && !usedMarginEnd) {
>             auto marginStartAndEnd = containingBlockWidth - (*left + borderLeft + paddingLeft + *width + paddingRight + borderRight + *right);
>             if (marginStartAndEnd >= 0)
>-                marginStart = marginEnd = marginStartAndEnd / 2;  
>+                usedMarginStart = usedMarginEnd = marginStartAndEnd / 2;  
>             else {
>                 if (isLeftToRightDirection) {
>-                    marginStart = 0_lu;
>-                    marginEnd = containingBlockWidth - (*left + *marginStart + borderLeft + paddingLeft + *width + paddingRight + borderRight + *right);
>+                    usedMarginStart = 0_lu;
>+                    usedMarginEnd = containingBlockWidth - (*left + *usedMarginStart + borderLeft + paddingLeft + *width + paddingRight + borderRight + *right);
>                 } else {
>-                    marginEnd = 0_lu;
>-                    marginStart = containingBlockWidth - (*left + borderLeft + paddingLeft + *width + paddingRight + borderRight + *marginEnd + *right);
>+                    usedMarginEnd = 0_lu;
>+                    usedMarginStart = containingBlockWidth - (*left + borderLeft + paddingLeft + *width + paddingRight + borderRight + *usedMarginEnd + *right);
>                 }
>             }
>-        } else if (!marginStart) {
>-            marginStart = containingBlockWidth - (*left + borderLeft + paddingLeft + *width + paddingRight + borderRight + *marginEnd + *right);
>+        } else if (!usedMarginStart) {
>+            usedMarginStart = containingBlockWidth - (*left + borderLeft + paddingLeft + *width + paddingRight + borderRight + *usedMarginEnd + *right);
>             // Overconstrained? Ignore right (left).
>-            if (*marginStart < 0) {
>+            if (*usedMarginStart < 0) {
>                 if (isLeftToRightDirection)
>-                    marginStart = containingBlockWidth - (*left + borderLeft + paddingLeft + *width + paddingRight + borderRight + *marginEnd);
>+                    usedMarginStart = containingBlockWidth - (*left + borderLeft + paddingLeft + *width + paddingRight + borderRight + *usedMarginEnd);
>                 else
>-                    marginStart = containingBlockWidth - (borderLeft + paddingLeft + *width + paddingRight + borderRight + *marginEnd + *right);
>+                    usedMarginStart = containingBlockWidth - (borderLeft + paddingLeft + *width + paddingRight + borderRight + *usedMarginEnd + *right);
>             }
>-        } else if (!marginEnd) {
>-            marginEnd = containingBlockWidth - (*left + *marginStart + borderLeft + paddingLeft + *width + paddingRight + borderRight + *right);
>+        } else if (!usedMarginEnd) {
>+            usedMarginEnd = containingBlockWidth - (*left + *usedMarginStart + borderLeft + paddingLeft + *width + paddingRight + borderRight + *right);
>             // Overconstrained? Ignore right (left).
>-            if (*marginEnd < 0) {
>+            if (*usedMarginEnd < 0) {
>                 if (isLeftToRightDirection)
>-                    marginEnd = containingBlockWidth - (*left + *marginStart + borderLeft + paddingLeft + *width + paddingRight + borderRight);
>+                    usedMarginEnd = containingBlockWidth - (*left + *usedMarginStart + borderLeft + paddingLeft + *width + paddingRight + borderRight);
>                 else
>-                    marginEnd = containingBlockWidth - (*marginStart + borderLeft + paddingLeft + *width + paddingRight + borderRight + *right);
>+                    usedMarginEnd = containingBlockWidth - (*usedMarginStart + borderLeft + paddingLeft + *width + paddingRight + borderRight + *right);
>             }
>         }
>     } else {
>         // Otherwise, set 'auto' values for 'margin-left' and 'margin-right' to 0, and pick the one of the following six rules that applies.
>-        marginStart = marginStart.valueOr(0);
>-        marginEnd = marginEnd.valueOr(0);
>+        usedMarginStart = usedMarginStart.valueOr(0);
>+        usedMarginEnd = usedMarginEnd.valueOr(0);
>     }
> 
>-    ASSERT(marginStart);
>-    ASSERT(marginEnd);
>+    ASSERT(usedMarginStart);
>+    ASSERT(usedMarginEnd);
> 
>     if (!left && !width && right) {
>         // #1
>         width = shrinkToFitWidth(layoutState, layoutBox);
>-        left = containingBlockWidth - (*marginStart + borderLeft + paddingLeft + *width + paddingRight  + borderRight + *marginEnd + *right);
>+        left = containingBlockWidth - (*usedMarginStart + borderLeft + paddingLeft + *width + paddingRight  + borderRight + *usedMarginEnd + *right);
>     } else if (!left && !right && width) {
>         // #2
>         auto staticHorizontalPosition = staticHorizontalPositionForOutOfFlowPositioned(layoutState, layoutBox);
>         if (isLeftToRightDirection) {
>             left = staticHorizontalPosition;
>-            right = containingBlockWidth - (*left + *marginStart + borderLeft + paddingLeft + *width + paddingRight + borderRight + *marginEnd);
>+            right = containingBlockWidth - (*left + *usedMarginStart + borderLeft + paddingLeft + *width + paddingRight + borderRight + *usedMarginEnd);
>         } else {
>             right = staticHorizontalPosition;
>-            left = containingBlockWidth - (*marginStart + borderLeft + paddingLeft + *width + paddingRight + borderRight + *marginEnd + *right);
>+            left = containingBlockWidth - (*usedMarginStart + borderLeft + paddingLeft + *width + paddingRight + borderRight + *usedMarginEnd + *right);
>         }
>     } else if (!width && !right && left) {
>         // #3
>         width = shrinkToFitWidth(layoutState, layoutBox);
>-        right = containingBlockWidth - (*left + *marginStart + borderLeft + paddingLeft + *width + paddingRight + borderRight + *marginEnd);
>+        right = containingBlockWidth - (*left + *usedMarginStart + borderLeft + paddingLeft + *width + paddingRight + borderRight + *usedMarginEnd);
>     } else if (!left && width && right) {
>         // #4
>-        left = containingBlockWidth - (*marginStart + borderLeft + paddingLeft + *width + paddingRight + borderRight + *marginEnd + *right);
>+        left = containingBlockWidth - (*usedMarginStart + borderLeft + paddingLeft + *width + paddingRight + borderRight + *usedMarginEnd + *right);
>     } else if (!width && left && right) {
>         // #5
>-        width = containingBlockWidth - (*left + *marginStart + borderLeft + paddingLeft + paddingRight  + borderRight + *marginEnd + *right);
>+        width = containingBlockWidth - (*left + *usedMarginStart + borderLeft + paddingLeft + paddingRight  + borderRight + *usedMarginEnd + *right);
>     } else if (!right && left && width) {
>         // #6
>-        right = containingBlockWidth - (*left + *marginStart + borderLeft + paddingLeft + *width + paddingRight + borderRight + *marginEnd);
>+        right = containingBlockWidth - (*left + *usedMarginStart + borderLeft + paddingLeft + *width + paddingRight + borderRight + *usedMarginEnd);
>     }
> 
>     ASSERT(left);
>     ASSERT(right);
>     ASSERT(width);
>-    ASSERT(marginStart);
>-    ASSERT(marginEnd);
>+    ASSERT(usedMarginStart);
>+    ASSERT(usedMarginEnd);
> 
>-    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Position][Width][Margin] -> out-of-flow non-replaced -> left(" << *left << "px) right("  << *right << "px) width(" << *width << "px) margin(" << *marginStart << "px, "  << *marginEnd << "px) layoutBox(" << &layoutBox << ")");
>-    return { *left, *right, { *width, { *marginStart, *marginEnd }, { nonComputedMarginStart, nonComputedMarginEnd } } };
>+    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Position][Width][Margin] -> out-of-flow non-replaced -> left(" << *left << "px) right("  << *right << "px) width(" << *width << "px) margin(" << *usedMarginStart << "px, "  << *usedMarginEnd << "px) layoutBox(" << &layoutBox << ")");
>+    return { *left, *right, { *width, { *usedMarginStart, *usedMarginEnd }, { computedMarginStart.valueOr(0), computedMarginEnd.valueOr(0) } } };
> }
> 
> VerticalGeometry FormattingContext::Geometry::outOfFlowReplacedVerticalGeometry(const LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedHeight)
>@@ -528,8 +530,10 @@ VerticalGeometry FormattingContext::Geometry::outOfFlowReplacedVerticalGeometry(
>     auto top = computedValueIfNotAuto(style.logicalTop(), containingBlockWidth);
>     auto bottom = computedValueIfNotAuto(style.logicalBottom(), containingBlockWidth);
>     auto height = inlineReplacedHeightAndMargin(layoutState, layoutBox, usedHeight).height;
>-    auto marginBefore = computedValueIfNotAuto(style.marginBefore(), containingBlockWidth);
>-    auto marginAfter = computedValueIfNotAuto(style.marginAfter(), containingBlockWidth);
>+    auto computedMarginBefore = computedValueIfNotAuto(style.marginBefore(), containingBlockWidth);
>+    auto computedMarginAfter = computedValueIfNotAuto(style.marginAfter(), containingBlockWidth);
>+    auto usedMarginBefore = computedMarginBefore;
>+    auto usedMarginAfter = computedMarginAfter;
>     auto paddingTop = displayBox.paddingTop().valueOr(0);
>     auto paddingBottom = displayBox.paddingBottom().valueOr(0);
>     auto borderTop = displayBox.borderTop();
>@@ -542,36 +546,36 @@ VerticalGeometry FormattingContext::Geometry::outOfFlowReplacedVerticalGeometry(
> 
>     if (!bottom) {
>         // #2
>-        marginBefore = marginBefore.valueOr(0);
>-        marginAfter = marginAfter.valueOr(0);
>+        usedMarginBefore = usedMarginBefore.valueOr(0);
>+        usedMarginAfter = usedMarginAfter.valueOr(0);
>     }
> 
>-    if (!marginBefore && !marginAfter) {
>+    if (!usedMarginBefore && !usedMarginAfter) {
>         // #3
>         auto marginBeforeAndAfter = containingBlockHeight - (*top + borderTop + paddingTop + height + paddingBottom + borderBottom + *bottom);
>-        marginBefore = marginAfter = marginBeforeAndAfter / 2;
>+        usedMarginBefore = usedMarginAfter = marginBeforeAndAfter / 2;
>     }
> 
>     // #4
>     if (!top)
>-        top = containingBlockHeight - (*marginBefore + borderTop + paddingTop + height + paddingBottom + borderBottom + *marginAfter + *bottom);
>+        top = containingBlockHeight - (*usedMarginBefore + borderTop + paddingTop + height + paddingBottom + borderBottom + *usedMarginAfter + *bottom);
> 
>     if (!bottom)
>-        bottom = containingBlockHeight - (*top + *marginBefore + borderTop + paddingTop + height + paddingBottom + borderBottom + *marginAfter);
>+        bottom = containingBlockHeight - (*top + *usedMarginBefore + borderTop + paddingTop + height + paddingBottom + borderBottom + *usedMarginAfter);
> 
>-    if (!marginBefore)
>-        marginBefore = containingBlockHeight - (*top + borderTop + paddingTop + height + paddingBottom + borderBottom + *marginAfter + *bottom);
>+    if (!usedMarginBefore)
>+        usedMarginBefore = containingBlockHeight - (*top + borderTop + paddingTop + height + paddingBottom + borderBottom + *usedMarginAfter + *bottom);
> 
>-    if (!marginAfter)
>-        marginAfter = containingBlockHeight - (*top + *marginBefore + borderTop + paddingTop + height + paddingBottom + borderBottom + *bottom);
>+    if (!usedMarginAfter)
>+        usedMarginAfter = containingBlockHeight - (*top + *usedMarginBefore + borderTop + paddingTop + height + paddingBottom + borderBottom + *bottom);
> 
>     // #5
>-    auto boxHeight = *top + *marginBefore + borderTop + paddingTop + height + paddingBottom + borderBottom + *marginAfter + *bottom;
>+    auto boxHeight = *top + *usedMarginBefore + borderTop + paddingTop + height + paddingBottom + borderBottom + *usedMarginAfter + *bottom;
>     if (boxHeight > containingBlockHeight)
>-        bottom = containingBlockHeight - (*top + *marginBefore + borderTop + paddingTop + height + paddingBottom + borderBottom + *marginAfter); 
>+        bottom = containingBlockHeight - (*top + *usedMarginBefore + borderTop + paddingTop + height + paddingBottom + borderBottom + *usedMarginAfter); 
> 
>-    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Position][Height][Margin] -> out-of-flow replaced -> top(" << *top << "px) bottom("  << *bottom << "px) height(" << height << "px) margin(" << *marginBefore << "px, "  << *marginAfter << "px) layoutBox(" << &layoutBox << ")");
>-    return { *top, *bottom, { height, { { *marginBefore, *marginAfter }, { } } } };
>+    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Position][Height][Margin] -> out-of-flow replaced -> top(" << *top << "px) bottom("  << *bottom << "px) height(" << height << "px) margin(" << *usedMarginBefore << "px, "  << *usedMarginAfter << "px) layoutBox(" << &layoutBox << ")");
>+    return { *top, *bottom, { height, { { *usedMarginBefore, *usedMarginAfter }, { } } } };
> }
> 
> HorizontalGeometry FormattingContext::Geometry::outOfFlowReplacedHorizontalGeometry(const LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedWidth)
>@@ -600,10 +604,10 @@ HorizontalGeometry FormattingContext::Geometry::outOfFlowReplacedHorizontalGeome
> 
>     auto left = computedValueIfNotAuto(style.logicalLeft(), containingBlockWidth);
>     auto right = computedValueIfNotAuto(style.logicalRight(), containingBlockWidth);
>-    auto marginStart = computedValueIfNotAuto(style.marginStart(), containingBlockWidth);
>-    auto marginEnd = computedValueIfNotAuto(style.marginEnd(), containingBlockWidth);
>-    auto nonComputedMarginStart = marginStart.valueOr(0);
>-    auto nonComputedMarginEnd = marginEnd.valueOr(0);
>+    auto computedMarginStart = computedValueIfNotAuto(style.marginStart(), containingBlockWidth);
>+    auto computedMarginEnd = computedValueIfNotAuto(style.marginEnd(), containingBlockWidth);
>+    auto usedMarginStart = computedMarginStart;
>+    auto usedMarginEnd = computedMarginEnd;
>     auto width = inlineReplacedWidthAndMargin(layoutState, layoutBox, usedWidth).width;
>     auto paddingLeft = displayBox.paddingLeft().valueOr(0);
>     auto paddingRight = displayBox.paddingRight().valueOr(0);
>@@ -621,55 +625,55 @@ HorizontalGeometry FormattingContext::Geometry::outOfFlowReplacedHorizontalGeome
> 
>     if (!left || !right) {
>         // #2
>-        marginStart = marginStart.valueOr(0); 
>-        marginEnd = marginEnd.valueOr(0); 
>+        usedMarginStart = usedMarginStart.valueOr(0); 
>+        usedMarginEnd = usedMarginEnd.valueOr(0); 
>     }
> 
>-    if (!marginStart && !marginEnd) {
>+    if (!usedMarginStart && !usedMarginEnd) {
>         // #3
>         auto marginStartAndEnd = containingBlockWidth - (*left + borderLeft + paddingLeft + width + paddingRight + borderRight + *right);
>         if (marginStartAndEnd >= 0)
>-            marginStart = marginEnd = marginStartAndEnd / 2;
>+            usedMarginStart = usedMarginEnd = marginStartAndEnd / 2;
>         else {
>             if (isLeftToRightDirection) {
>-                marginStart = 0_lu;
>-                marginEnd = containingBlockWidth - (*left + *marginStart + borderLeft + paddingLeft + width + paddingRight + borderRight + *right);
>+                usedMarginStart = 0_lu;
>+                usedMarginEnd = containingBlockWidth - (*left + *usedMarginStart + borderLeft + paddingLeft + width + paddingRight + borderRight + *right);
>             } else {
>-                marginEnd = 0_lu;
>-                marginStart = containingBlockWidth - (*left + borderLeft + paddingLeft + width + paddingRight + borderRight + *marginEnd + *right);
>+                usedMarginEnd = 0_lu;
>+                usedMarginStart = containingBlockWidth - (*left + borderLeft + paddingLeft + width + paddingRight + borderRight + *usedMarginEnd + *right);
>             }
>         }
>     }
> 
>     // #4
>     if (!left)
>-        left = containingBlockWidth - (*marginStart + borderLeft + paddingLeft + width + paddingRight + borderRight + *marginEnd + *right);
>+        left = containingBlockWidth - (*usedMarginStart + borderLeft + paddingLeft + width + paddingRight + borderRight + *usedMarginEnd + *right);
> 
>     if (!right)
>-        right = containingBlockWidth - (*left + *marginStart + borderLeft + paddingLeft + width + paddingRight + borderRight + *marginEnd);
>+        right = containingBlockWidth - (*left + *usedMarginStart + borderLeft + paddingLeft + width + paddingRight + borderRight + *usedMarginEnd);
> 
>-    if (!marginStart)
>-        marginStart = containingBlockWidth - (*left + borderLeft + paddingLeft + width + paddingRight + borderRight + *marginEnd + *right);
>+    if (!usedMarginStart)
>+        usedMarginStart = containingBlockWidth - (*left + borderLeft + paddingLeft + width + paddingRight + borderRight + *usedMarginEnd + *right);
> 
>-    if (!marginEnd)
>-        marginEnd = containingBlockWidth - (*left + *marginStart + borderLeft + paddingLeft + width + paddingRight + borderRight + *right);
>+    if (!usedMarginEnd)
>+        usedMarginEnd = containingBlockWidth - (*left + *usedMarginStart + borderLeft + paddingLeft + width + paddingRight + borderRight + *right);
> 
>-    auto boxWidth = (*left + *marginStart + borderLeft + paddingLeft + width + paddingRight + borderRight + *marginEnd + *right);
>+    auto boxWidth = (*left + *usedMarginStart + borderLeft + paddingLeft + width + paddingRight + borderRight + *usedMarginEnd + *right);
>     if (boxWidth > containingBlockWidth) {
>         // #5 Over-constrained?
>         if (isLeftToRightDirection)
>-            right = containingBlockWidth - (*left + *marginStart + borderLeft + paddingLeft + width + paddingRight + borderRight + *marginEnd);
>+            right = containingBlockWidth - (*left + *usedMarginStart + borderLeft + paddingLeft + width + paddingRight + borderRight + *usedMarginEnd);
>         else
>-            left = containingBlockWidth - (*marginStart + borderLeft + paddingLeft + width + paddingRight + borderRight + *marginEnd + *right);
>+            left = containingBlockWidth - (*usedMarginStart + borderLeft + paddingLeft + width + paddingRight + borderRight + *usedMarginEnd + *right);
>     }
> 
>     ASSERT(left);
>     ASSERT(right);
>-    ASSERT(marginStart);
>-    ASSERT(marginEnd);
>+    ASSERT(usedMarginStart);
>+    ASSERT(usedMarginEnd);
> 
>-    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Position][Width][Margin] -> out-of-flow replaced -> left(" << *left << "px) right("  << *right << "px) width(" << width << "px) margin(" << *marginStart << "px, "  << *marginEnd << "px) layoutBox(" << &layoutBox << ")");
>-    return { *left, *right, { width, { *marginStart, *marginEnd }, { nonComputedMarginStart, nonComputedMarginEnd } } };
>+    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Position][Width][Margin] -> out-of-flow replaced -> left(" << *left << "px) right("  << *right << "px) width(" << width << "px) margin(" << *usedMarginStart << "px, "  << *usedMarginEnd << "px) layoutBox(" << &layoutBox << ")");
>+    return { *left, *right, { width, { *usedMarginStart, *usedMarginEnd }, { computedMarginStart.valueOr(0), computedMarginEnd.valueOr(0) } } };
> }
> 
> HeightAndMargin FormattingContext::Geometry::complicatedCases(const LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedHeight)
>@@ -693,12 +697,13 @@ HeightAndMargin FormattingContext::Geometry::complicatedCases(const LayoutState&
>     auto containingBlockWidth = containingBlockDisplayBox.contentBoxWidth();
> 
>     auto height = usedHeight ? usedHeight.value() : computedHeightValue(layoutState, layoutBox, HeightType::Normal);
>-    auto marginBefore = computedValueIfNotAuto(style.marginBefore(), containingBlockWidth);
>-    auto marginAfter = computedValueIfNotAuto(style.marginAfter(), containingBlockWidth);
>+    auto computedMarginBefore = computedValueIfNotAuto(style.marginBefore(), containingBlockWidth);
>+    auto computedMarginAfter = computedValueIfNotAuto(style.marginAfter(), containingBlockWidth);
> 
>     // #1
>-    marginBefore = marginBefore.valueOr(0);
>-    marginAfter = marginAfter.valueOr(0);
>+    auto usedMarginBefore = computedMarginBefore.valueOr(0);
>+    auto usedMarginAfter = computedMarginAfter.valueOr(0);
>+
>     // #2
>     if (!height) {
>         ASSERT(isHeightAuto(layoutBox));
>@@ -706,11 +711,11 @@ HeightAndMargin FormattingContext::Geometry::complicatedCases(const LayoutState&
>     }
> 
>     ASSERT(height);
>-    ASSERT(marginBefore);
>-    ASSERT(marginAfter);
>+    ASSERT(usedMarginBefore);
>+    ASSERT(usedMarginAfter);
> 
>-    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> floating non-replaced -> height(" << *height << "px) margin(" << *marginBefore << "px, " << *marginAfter << "px) -> layoutBox(" << &layoutBox << ")");
>-    return HeightAndMargin { *height, { { *marginBefore, *marginAfter }, { } } };
>+    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> floating non-replaced -> height(" << *height << "px) margin(" << usedMarginBefore << "px, " << usedMarginAfter << "px) -> layoutBox(" << &layoutBox << ")");
>+    return HeightAndMargin { *height, { { usedMarginBefore, usedMarginAfter }, { } } };
> }
> 
> WidthAndMargin FormattingContext::Geometry::floatingNonReplacedWidthAndMargin(LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedWidth)
>@@ -869,29 +874,24 @@ WidthAndMargin FormattingContext::Geometry::inlineReplacedWidthAndMargin(const L
>     auto& containingBlockDisplayBox = layoutState.displayBoxForLayoutBox(*layoutBox.containingBlock());
>     auto containingBlockWidth = containingBlockDisplayBox.width();
> 
>-    auto computeMarginEnd = [&]() {
>-        if (precomputedMarginEnd)
>-            return precomputedMarginEnd.value();
>-        auto marginEnd = computedValueIfNotAuto(style.marginEnd(), containingBlockWidth);
>-        return marginEnd.valueOr(0_lu);
>-    };
>-
>-    auto computeMarginStart = [&]() {
>+    auto usedMarginStart = [&] {
>         if (precomputedMarginStart)
>             return precomputedMarginStart.value();
>         auto marginStart = computedValueIfNotAuto(style.marginStart(), containingBlockWidth);
>         return marginStart.valueOr(0_lu);
>     };
> 
>+    auto usedMarginEnd = [&] {
>+        if (precomputedMarginEnd)
>+            return precomputedMarginEnd.value();
>+        auto marginEnd = computedValueIfNotAuto(style.marginEnd(), containingBlockWidth);
>+        return marginEnd.valueOr(0_lu);
>+    };
>+
>     auto replaced = layoutBox.replaced();
>     ASSERT(replaced);
> 
>-    auto marginStart = computeMarginStart();
>-    auto marginEnd = computeMarginEnd();
>-    auto nonComputedMarginStart = computedValueIfNotAuto(style.marginStart(), containingBlockWidth).valueOr(0);
>-    auto nonComputedMarginEnd = computedValueIfNotAuto(style.marginEnd(), containingBlockWidth).valueOr(0);
>     auto width = computedValueIfNotAuto(usedWidth ? Length { usedWidth.value(), Fixed } : style.logicalWidth(), containingBlockWidth);
>-
>     auto heightIsAuto = isHeightAuto(layoutBox);
>     auto height = computedHeightValue(layoutState, layoutBox, HeightType::Normal);
> 
>@@ -916,8 +916,10 @@ WidthAndMargin FormattingContext::Geometry::inlineReplacedWidthAndMargin(const L
> 
>     ASSERT(width);
> 
>-    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Width][Margin] -> inflow replaced -> width(" << *width << "px) margin(" << marginStart << "px, " << marginEnd << "px) -> layoutBox(" << &layoutBox << ")");
>-    return { *width, { marginStart, marginEnd }, { nonComputedMarginStart, nonComputedMarginEnd } };
>+    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Width][Margin] -> inflow replaced -> width(" << *width << "px) margin(" << usedMarginStart() << "px, " << usedMarginEnd() << "px) -> layoutBox(" << &layoutBox << ")");
>+    auto computedMarginStart = computedValueIfNotAuto(style.marginStart(), containingBlockWidth);
>+    auto computedMarginEnd = computedValueIfNotAuto(style.marginEnd(), containingBlockWidth);
>+    return { *width, { usedMarginStart(), usedMarginEnd() }, { computedMarginStart.valueOr(0), computedMarginEnd.valueOr(0) } };
> }
> 
> LayoutSize FormattingContext::Geometry::inFlowPositionedPositionOffset(const LayoutState& layoutState, const Box& layoutBox)
>@@ -1037,11 +1039,11 @@ VerticalMargin::ComputedValues FormattingContext::Geometry::computedNonCollapsed
>     auto& style = layoutBox.style();
>     auto containingBlockWidth = layoutState.displayBoxForLayoutBox(*layoutBox.containingBlock()).contentBoxWidth();
> 
>-    auto marginBefore = computedValueIfNotAuto(style.marginBefore(), containingBlockWidth).valueOr(0_lu);
>-    auto marginAfter = computedValueIfNotAuto(style.marginAfter(), containingBlockWidth).valueOr(0_lu);
>+    auto usedMarginBefore = computedValueIfNotAuto(style.marginBefore(), containingBlockWidth).valueOr(0_lu);
>+    auto usedMarginAfter = computedValueIfNotAuto(style.marginAfter(), containingBlockWidth).valueOr(0_lu);
> 
>-    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Margin] -> non collapsed vertical -> margin(" << marginBefore << "px, " << marginAfter << "px) -> layoutBox: " << &layoutBox);
>-    return { marginBefore, marginAfter };
>+    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Margin] -> non collapsed vertical -> margin(" << usedMarginBefore << "px, " << usedMarginAfter << "px) -> layoutBox: " << &layoutBox);
>+    return { usedMarginBefore, usedMarginAfter };
> }
> 
> }
>diff --git a/Source/WebCore/layout/LayoutState.cpp b/Source/WebCore/layout/LayoutState.cpp
>index cc1dbc034ee8b97760e6869eb872f9e2cc976e73..fb644e72ff51782921d39f52f27930b3e31243eb 100644
>--- a/Source/WebCore/layout/LayoutState.cpp
>+++ b/Source/WebCore/layout/LayoutState.cpp
>@@ -54,7 +54,7 @@ LayoutState::LayoutState(const Container& initialContainingBlock, const LayoutSi
> 
>     auto& displayBox = displayBoxForLayoutBox(initialContainingBlock);
>     displayBox.setHorizontalMargin({ });
>-    displayBox.setHorizontalNonComputedMargin({ });
>+    displayBox.setHorizontalComputedMargin({ });
>     displayBox.setVerticalMargin({ });
>     displayBox.setBorder({ });
>     displayBox.setPadding({ });
>diff --git a/Source/WebCore/layout/LayoutUnits.h b/Source/WebCore/layout/LayoutUnits.h
>index d76b6a38565ef34aff44f9f810ab66e2f9e11422..70ae2bc4112d3a2538fea6c477d06014557bedcd 100644
>--- a/Source/WebCore/layout/LayoutUnits.h
>+++ b/Source/WebCore/layout/LayoutUnits.h
>@@ -103,9 +103,8 @@ struct Edges {
> 
> struct WidthAndMargin {
>     LayoutUnit width;
>-    HorizontalMargin margin;
>-    // FIXME: Figure out if we really really need this.
>-    HorizontalMargin nonComputedMargin;
>+    HorizontalMargin usedMargin;
>+    HorizontalMargin computedMargin;
> };
> 
> struct HeightAndMargin {
>diff --git a/Source/WebCore/layout/Verification.cpp b/Source/WebCore/layout/Verification.cpp
>index 8eb054743afa0ec5a8f2b834694c4e58719fc2f7..494157a9ee75b75f44c2536222aca82e7d00fc56 100644
>--- a/Source/WebCore/layout/Verification.cpp
>+++ b/Source/WebCore/layout/Verification.cpp
>@@ -247,8 +247,8 @@ static bool outputMismatchingBlockBoxInformationIfNeeded(TextStream& stream, con
> 
>         return Display::Box::Rect {
>             borderBox.top() - displayBox.nonCollapsedMarginBefore(),
>-            borderBox.left() - displayBox.nonComputedMarginStart(),
>-            displayBox.nonComputedMarginStart() + borderBox.width() + displayBox.nonComputedMarginEnd(),
>+            borderBox.left() - displayBox.computedMarginStart(),
>+            displayBox.computedMarginStart() + borderBox.width() + displayBox.computedMarginEnd(),
>             displayBox.nonCollapsedMarginBefore() + borderBox.height() + displayBox.nonCollapsedMarginAfter()
>         };
>     };
>diff --git a/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp b/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp
>index 429c0a9811a48dbf4551a4be92130f250143a38b..b8bfa9918af527e91ee1a9b9a2c289f385dea502 100644
>--- a/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp
>+++ b/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp
>@@ -331,9 +331,9 @@ void BlockFormattingContext::computeWidthAndMargin(const Box& layoutBox) const
> 
>     auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
>     displayBox.setContentBoxWidth(widthAndMargin.width);
>-    displayBox.moveHorizontally(widthAndMargin.margin.start);
>-    displayBox.setHorizontalMargin(widthAndMargin.margin);
>-    displayBox.setHorizontalNonComputedMargin(widthAndMargin.nonComputedMargin);
>+    displayBox.moveHorizontally(widthAndMargin.usedMargin.start);
>+    displayBox.setHorizontalMargin(widthAndMargin.usedMargin);
>+    displayBox.setHorizontalComputedMargin(widthAndMargin.computedMargin);
> }
> 
> void BlockFormattingContext::computeHeightAndMargin(const Box& layoutBox) const
>diff --git a/Source/WebCore/layout/blockformatting/BlockFormattingContextGeometry.cpp b/Source/WebCore/layout/blockformatting/BlockFormattingContextGeometry.cpp
>index ee43872eab6e500be8ac72b15af9010beebf8106..64a77584960c94ce57b6e07d651569186bdf0ba2 100644
>--- a/Source/WebCore/layout/blockformatting/BlockFormattingContextGeometry.cpp
>+++ b/Source/WebCore/layout/blockformatting/BlockFormattingContextGeometry.cpp
>@@ -141,10 +141,10 @@ WidthAndMargin BlockFormattingContext::Geometry::inFlowNonReplacedWidthAndMargin
>         auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
> 
>         auto width = computedValueIfNotAuto(usedWidth ? Length { usedWidth.value(), Fixed } : style.logicalWidth(), containingBlockWidth);
>-        auto marginStart = computedValueIfNotAuto(style.marginStart(), containingBlockWidth);
>-        auto marginEnd = computedValueIfNotAuto(style.marginEnd(), containingBlockWidth);
>-        auto nonComputedMarginStart = marginStart.valueOr(0);
>-        auto nonComputedMarginEnd = marginEnd.valueOr(0);
>+        auto computedMarginStart = computedValueIfNotAuto(style.marginStart(), containingBlockWidth);
>+        auto computedMarginEnd = computedValueIfNotAuto(style.marginEnd(), containingBlockWidth);
>+        auto usedMarginStart = computedMarginStart;
>+        auto usedMarginEnd = computedMarginEnd;
>         auto borderLeft = displayBox.borderLeft();
>         auto borderRight = displayBox.borderRight();
>         auto paddingLeft = displayBox.paddingLeft().valueOr(0);
>@@ -152,51 +152,51 @@ WidthAndMargin BlockFormattingContext::Geometry::inFlowNonReplacedWidthAndMargin
> 
>         // #1
>         if (width) {
>-            auto horizontalSpaceForMargin = containingBlockWidth - (marginStart.valueOr(0) + borderLeft + paddingLeft + *width + paddingRight + borderRight + marginEnd.valueOr(0));
>+            auto horizontalSpaceForMargin = containingBlockWidth - (usedMarginStart.valueOr(0) + borderLeft + paddingLeft + *width + paddingRight + borderRight + usedMarginEnd.valueOr(0));
>             if (horizontalSpaceForMargin < 0) {
>-                marginStart = marginStart.valueOr(0);
>-                marginEnd = marginEnd.valueOr(0);
>+                usedMarginStart = usedMarginStart.valueOr(0);
>+                usedMarginEnd = usedMarginEnd.valueOr(0);
>             }
>         }
> 
>         // #2
>-        if (width && marginStart && marginEnd) {
>+        if (width && usedMarginStart && usedMarginEnd) {
>             if (containingBlock->style().isLeftToRightDirection())
>-                marginEnd = containingBlockWidth - (*marginStart + borderLeft + paddingLeft  + *width + paddingRight + borderRight);
>+                usedMarginEnd = containingBlockWidth - (*usedMarginStart + borderLeft + paddingLeft  + *width + paddingRight + borderRight);
>             else
>-                marginStart = containingBlockWidth - (borderLeft + paddingLeft + *width + paddingRight + borderRight + *marginEnd);
>+                usedMarginStart = containingBlockWidth - (borderLeft + paddingLeft + *width + paddingRight + borderRight + *usedMarginEnd);
>         }
> 
>         // #3
>-        if (!marginStart && width && marginEnd)
>-            marginStart = containingBlockWidth - (borderLeft + paddingLeft  + *width + paddingRight + borderRight + *marginEnd);
>-        else if (marginStart && !width && marginEnd)
>-            width = containingBlockWidth - (*marginStart + borderLeft + paddingLeft + paddingRight + borderRight + *marginEnd);
>-        else if (marginStart && width && !marginEnd)
>-            marginEnd = containingBlockWidth - (*marginStart + borderLeft + paddingLeft + *width + paddingRight + borderRight);
>+        if (!usedMarginStart && width && usedMarginEnd)
>+            usedMarginStart = containingBlockWidth - (borderLeft + paddingLeft  + *width + paddingRight + borderRight + *usedMarginEnd);
>+        else if (usedMarginStart && !width && usedMarginEnd)
>+            width = containingBlockWidth - (*usedMarginStart + borderLeft + paddingLeft + paddingRight + borderRight + *usedMarginEnd);
>+        else if (usedMarginStart && width && !usedMarginEnd)
>+            usedMarginEnd = containingBlockWidth - (*usedMarginStart + borderLeft + paddingLeft + *width + paddingRight + borderRight);
> 
>         // #4
>         if (!width) {
>-            marginStart = marginStart.valueOr(0);
>-            marginEnd = marginEnd.valueOr(0);
>-            width = containingBlockWidth - (*marginStart + borderLeft + paddingLeft + paddingRight + borderRight + *marginEnd);
>+            usedMarginStart = usedMarginStart.valueOr(0);
>+            usedMarginEnd = usedMarginEnd.valueOr(0);
>+            width = containingBlockWidth - (*usedMarginStart + borderLeft + paddingLeft + paddingRight + borderRight + *usedMarginEnd);
>         }
> 
>         // #5
>-        if (!marginStart && !marginEnd) {
>+        if (!usedMarginStart && !usedMarginEnd) {
>             auto horizontalSpaceForMargin = containingBlockWidth - (borderLeft + paddingLeft  + *width + paddingRight + borderRight);
>-            marginStart = marginEnd = horizontalSpaceForMargin / 2;
>+            usedMarginStart = usedMarginEnd = horizontalSpaceForMargin / 2;
>         }
> 
>         ASSERT(width);
>-        ASSERT(marginStart);
>-        ASSERT(marginEnd);
>+        ASSERT(usedMarginStart);
>+        ASSERT(usedMarginEnd);
> 
>-        return WidthAndMargin { *width, { *marginStart, *marginEnd }, { nonComputedMarginStart, nonComputedMarginEnd } };
>+        return WidthAndMargin { *width, { *usedMarginStart, *usedMarginEnd }, { computedMarginStart.valueOr(0), computedMarginEnd.valueOr(0) } };
>     };
> 
>     auto widthAndMargin = compute();
>-    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Width][Margin] -> inflow non-replaced -> width(" << widthAndMargin.width << "px) margin(" << widthAndMargin.margin.start << "px, " << widthAndMargin.margin.end << "px) -> layoutBox(" << &layoutBox << ")");
>+    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Width][Margin] -> inflow non-replaced -> width(" << widthAndMargin.width << "px) margin(" << widthAndMargin.usedMargin.start << "px, " << widthAndMargin.usedMargin.end << "px) -> layoutBox(" << &layoutBox << ")");
>     return widthAndMargin;
> }
> 
>@@ -214,8 +214,8 @@ WidthAndMargin BlockFormattingContext::Geometry::inFlowReplacedWidthAndMargin(co
>     // #2
>     auto nonReplacedWidthAndMargin = inFlowNonReplacedWidthAndMargin(layoutState, layoutBox, width);
> 
>-    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Width][Margin] -> inflow replaced -> width(" << width << "px) margin(" << nonReplacedWidthAndMargin.margin.start << "px, " << nonReplacedWidthAndMargin.margin.end << "px) -> layoutBox(" << &layoutBox << ")");
>-    return { width, nonReplacedWidthAndMargin.margin, nonReplacedWidthAndMargin.nonComputedMargin };
>+    LOG_WITH_STREAM(FormattingContextLayout, stream << "[Width][Margin] -> inflow replaced -> width(" << width << "px) margin(" << nonReplacedWidthAndMargin.usedMargin.start << "px, " << nonReplacedWidthAndMargin.usedMargin.end << "px) -> layoutBox(" << &layoutBox << ")");
>+    return { width, nonReplacedWidthAndMargin.usedMargin, nonReplacedWidthAndMargin.computedMargin };
> }
> 
> Point BlockFormattingContext::Geometry::staticPosition(const LayoutState& layoutState, const Box& layoutBox)
>diff --git a/Source/WebCore/layout/displaytree/DisplayBox.cpp b/Source/WebCore/layout/displaytree/DisplayBox.cpp
>index 027b434bbc6d4c2f5510afce9c507839e649e244..3140a55afab4cf12b3f55ffb7b1261f1d796f1ae 100644
>--- a/Source/WebCore/layout/displaytree/DisplayBox.cpp
>+++ b/Source/WebCore/layout/displaytree/DisplayBox.cpp
>@@ -59,7 +59,7 @@ Box::Box(const Box& other)
>     , m_contentHeight(other.m_contentHeight)
>     , m_horizontalMargin(other.m_horizontalMargin)
>     , m_verticalMargin(other.m_verticalMargin)
>-    , m_horizontalNonComputedMargin(other.m_horizontalNonComputedMargin)
>+    , m_horizontalComputedMargin(other.m_horizontalComputedMargin)
>     , m_estimatedMarginBefore(other.m_estimatedMarginBefore)
>     , m_border(other.m_border)
>     , m_padding(other.m_padding)
>@@ -69,7 +69,7 @@ Box::Box(const Box& other)
>     , m_hasValidHorizontalMargin(other.m_hasValidHorizontalMargin)
>     , m_hasValidVerticalMargin(other.m_hasValidVerticalMargin)
>     , m_hasValidVerticalNonCollapsedMargin(other.m_hasValidVerticalNonCollapsedMargin)
>-    , m_hasValidHorizontalNonComputedMargin(other.m_hasValidHorizontalNonComputedMargin)
>+    , m_hasValidHorizontalComputedMargin(other.m_hasValidHorizontalComputedMargin)
>     , m_hasValidBorder(other.m_hasValidBorder)
>     , m_hasValidPadding(other.m_hasValidPadding)
>     , m_hasValidContentHeight(other.m_hasValidContentHeight)
>diff --git a/Source/WebCore/layout/displaytree/DisplayBox.h b/Source/WebCore/layout/displaytree/DisplayBox.h
>index 56392f47ee79e30d3f0e21894d3f14bb875d7e89..75ec77187a46ec2ffdf81e5ba71187634a73637e 100644
>--- a/Source/WebCore/layout/displaytree/DisplayBox.h
>+++ b/Source/WebCore/layout/displaytree/DisplayBox.h
>@@ -146,8 +146,8 @@ public:
> 
>     LayoutUnit nonCollapsedMarginBefore() const;
>     LayoutUnit nonCollapsedMarginAfter() const;
>-    LayoutUnit nonComputedMarginStart() const;
>-    LayoutUnit nonComputedMarginEnd() const;
>+    LayoutUnit computedMarginStart() const;
>+    LayoutUnit computedMarginEnd() const;
> 
>     Optional<LayoutUnit> estimatedMarginBefore() const { return m_estimatedMarginBefore; }
> 
>@@ -193,7 +193,7 @@ private:
> 
>     void setHorizontalMargin(Layout::HorizontalMargin);
>     void setVerticalMargin(Layout::VerticalMargin);
>-    void setHorizontalNonComputedMargin(Layout::HorizontalMargin);
>+    void setHorizontalComputedMargin(Layout::HorizontalMargin);
>     void setEstimatedMarginBefore(LayoutUnit marginBefore) { m_estimatedMarginBefore = marginBefore; }
> 
>     void setBorder(Layout::Edges);
>@@ -208,7 +208,7 @@ private:
>     void setHasValidLeft() { m_hasValidLeft = true; }
>     void setHasValidVerticalMargin() { m_hasValidVerticalMargin = true; }
>     void setHasValidVerticalNonCollapsedMargin() { m_hasValidVerticalNonCollapsedMargin = true; }
>-    void setHasValidHorizontalNonComputedMargin() { m_hasValidHorizontalNonComputedMargin = true; }
>+    void setHasValidHorizontalComputedMargin() { m_hasValidHorizontalComputedMargin = true; }
>     void setHasValidHorizontalMargin() { m_hasValidHorizontalMargin = true; }
> 
>     void setHasValidBorder() { m_hasValidBorder = true; }
>@@ -226,7 +226,7 @@ private:
> 
>     Layout::HorizontalMargin m_horizontalMargin;
>     Layout::VerticalMargin m_verticalMargin;
>-    Layout::HorizontalMargin m_horizontalNonComputedMargin;
>+    Layout::HorizontalMargin m_horizontalComputedMargin;
>     Optional<LayoutUnit> m_estimatedMarginBefore;
> 
>     Layout::Edges m_border;
>@@ -238,7 +238,7 @@ private:
>     bool m_hasValidHorizontalMargin { false };
>     bool m_hasValidVerticalMargin { false };
>     bool m_hasValidVerticalNonCollapsedMargin { false };
>-    bool m_hasValidHorizontalNonComputedMargin { false };
>+    bool m_hasValidHorizontalComputedMargin { false };
>     bool m_hasValidBorder { false };
>     bool m_hasValidPadding { false };
>     bool m_hasValidContentHeight { false };
>@@ -525,12 +525,12 @@ inline void Box::setVerticalMargin(Layout::VerticalMargin margin)
>     m_verticalMargin = margin;
> }
> 
>-inline void Box::setHorizontalNonComputedMargin(Layout::HorizontalMargin margin)
>+inline void Box::setHorizontalComputedMargin(Layout::HorizontalMargin margin)
> {
> #if !ASSERT_DISABLED
>-    setHasValidHorizontalNonComputedMargin();
>+    setHasValidHorizontalComputedMargin();
> #endif
>-    m_horizontalNonComputedMargin = margin;
>+    m_horizontalComputedMargin = margin;
> }
> 
> inline void Box::setBorder(Layout::Edges border)
>@@ -591,16 +591,16 @@ inline LayoutUnit Box::nonCollapsedMarginAfter() const
>     return m_verticalMargin.nonCollapsedValues().after;
> }
> 
>-inline LayoutUnit Box::nonComputedMarginStart() const
>+inline LayoutUnit Box::computedMarginStart() const
> {
>-    ASSERT(m_hasValidHorizontalNonComputedMargin);
>-    return m_horizontalNonComputedMargin.start;
>+    ASSERT(m_hasValidHorizontalComputedMargin);
>+    return m_horizontalComputedMargin.start;
> }
> 
>-inline LayoutUnit Box::nonComputedMarginEnd() const
>+inline LayoutUnit Box::computedMarginEnd() const
> {
>-    ASSERT(m_hasValidHorizontalNonComputedMargin);
>-    return m_horizontalNonComputedMargin.end;
>+    ASSERT(m_hasValidHorizontalComputedMargin);
>+    return m_horizontalComputedMargin.end;
> }
> 
> inline Optional<LayoutUnit> Box::paddingTop() const
>diff --git a/Source/WebCore/layout/floats/FloatAvoider.h b/Source/WebCore/layout/floats/FloatAvoider.h
>index 7d46690494d4ee6b81c183c28a2de3b4b2fda662..8b5cd884058477131395b4a9e5a0e81a6c1a629c 100644
>--- a/Source/WebCore/layout/floats/FloatAvoider.h
>+++ b/Source/WebCore/layout/floats/FloatAvoider.h
>@@ -72,8 +72,9 @@ protected:
> 
>     LayoutUnit marginBefore() const { return displayBox().marginBefore(); }
>     LayoutUnit marginAfter() const { return displayBox().marginAfter(); }
>-    LayoutUnit marginStart() const { return displayBox().nonComputedMarginStart(); }
>-    LayoutUnit marginEnd() const { return displayBox().nonComputedMarginEnd(); }
>+    // Do not use the used values here because they computed as if this box was not a float avoider.
>+    LayoutUnit marginStart() const { return displayBox().computedMarginStart(); }
>+    LayoutUnit marginEnd() const { return displayBox().computedMarginEnd(); }
> 
>     LayoutUnit marginBoxWidth() const { return marginStart() + displayBox().width() + marginEnd(); }
> 
>diff --git a/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp b/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp
>index e21b874072756ade164bb8f70605759805069743..5c5f3edb723b3a26c1e760e16c9be000dbd00f75 100644
>--- a/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp
>+++ b/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp
>@@ -342,8 +342,8 @@ void InlineFormattingContext::computeWidthAndMargin(const Box& layoutBox) const
> 
>     auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
>     displayBox.setContentBoxWidth(widthAndMargin.width);
>-    displayBox.setHorizontalMargin(widthAndMargin.margin);
>-    displayBox.setHorizontalNonComputedMargin(widthAndMargin.nonComputedMargin);
>+    displayBox.setHorizontalMargin(widthAndMargin.usedMargin);
>+    displayBox.setHorizontalComputedMargin(widthAndMargin.computedMargin);
> }
> 
> void InlineFormattingContext::computeHeightAndMargin(const Box& layoutBox) const

Actions: View | Formatted Diff | Diff

Attachments on bug 193059: 358145 | 358258 | 358299