Changeset 256702 in webkit

Timestamp:

Feb 15, 2020, 7:17:40 AM (6 years ago)

Author:

Alan Bujtas

Message:

[LFC] Introduce OutOfFlowHorizontalConstraints
​https://bugs.webkit.org/show_bug.cgi?id=207805
<rdar://problem/59482286>

Reviewed by Antti Koivisto.

Borders and paddings are resolved against the containing block's content box as if the box was an in-flow box.

• layout/FormattingContext.cpp:

(WebCore::Layout::FormattingContext::layoutOutOfFlowContent):

• layout/FormattingContext.h:
• layout/FormattingContextGeometry.cpp:

(WebCore::Layout::FormattingContext::Geometry::horizontalConstraintsForOutOfFlow):

• layout/LayoutContext.cpp:

(WebCore::Layout::LayoutContext::layoutFormattingContextSubtree):

• layout/LayoutUnits.h:
• layout/blockformatting/BlockFormattingContext.cpp:

(WebCore::Layout::BlockFormattingContext::layoutInFlowContent):

• layout/inlineformatting/InlineFormattingContext.cpp:

(WebCore::Layout::InlineFormattingContext::layoutInFlowContent):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• layout/FormattingContext.cpp (modified) (4 diffs)
• layout/FormattingContext.h (modified) (2 diffs)
• layout/FormattingContextGeometry.cpp (modified) (1 diff)
• layout/LayoutContext.cpp (modified) (1 diff)
• layout/LayoutUnits.h (modified) (1 diff)
• layout/blockformatting/BlockFormattingContext.cpp (modified) (2 diffs)
• layout/inlineformatting/InlineFormattingContext.cpp (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2020-02-15  Zalan Bujtas  <zalan@apple.com>
+
+        [LFC] Introduce OutOfFlowHorizontalConstraints
+        https://bugs.webkit.org/show_bug.cgi?id=207805
+        <rdar://problem/59482286>
+
+        Reviewed by Antti Koivisto.
+
+        Borders and paddings are resolved against the containing block's content box as if the box was an in-flow box.
+
+        * layout/FormattingContext.cpp:
+        (WebCore::Layout::FormattingContext::layoutOutOfFlowContent):
+        * layout/FormattingContext.h:
+        * layout/FormattingContextGeometry.cpp:
+        (WebCore::Layout::FormattingContext::Geometry::horizontalConstraintsForOutOfFlow):
+        * layout/LayoutContext.cpp:
+        (WebCore::Layout::LayoutContext::layoutFormattingContextSubtree):
+        * layout/LayoutUnits.h:
+        * layout/blockformatting/BlockFormattingContext.cpp:
+        (WebCore::Layout::BlockFormattingContext::layoutInFlowContent):
+        * layout/inlineformatting/InlineFormattingContext.cpp:
+        (WebCore::Layout::InlineFormattingContext::layoutInFlowContent):
+
 2020-02-15  Zalan Bujtas  <zalan@apple.com>
 

trunk/Source/WebCore/layout/FormattingContext.cpp

@@ -133 +133 @@
 }
 
-void FormattingContext::layoutOutOfFlowContent(InvalidationState& invalidationState, const HorizontalConstraints& rootHorizontalConstraints, const VerticalConstraints& rootVerticalConstraints)
+void FormattingContext::layoutOutOfFlowContent(InvalidationState& invalidationState, const OutOfFlowHorizontalConstraints& rootHorizontalConstraints, const VerticalConstraints& rootVerticalConstraints)
 {
     LOG_WITH_STREAM(FormattingContextLayout, stream << "Start: layout out-of-flow content -> context: " << &layoutState() << " root: " << &root());
@@ -139 +139 @@
     collectOutOfFlowDescendantsIfNeeded();
 
-    auto horizontalConstraintsForOutOfFlowBox = [&] (const auto& outOfFlowBox) {
+    auto horizontalConstraintsForLayoutBox = [&] (const auto& outOfFlowBox) {
         auto* containingBlock = outOfFlowBox.containingBlock();
         ASSERT(containingBlock);
@@ -147 +147 @@
     };
 
-    auto verticalConstraintsForOutOfFlowBox = [&] (const auto& outOfFlowBox) {
+    auto verticalConstraintsForLayoutBox = [&] (const auto& outOfFlowBox) {
         auto* containingBlock = outOfFlowBox.containingBlock();
         ASSERT(containingBlock);
@@ -160 +160 @@
             continue;
 
-        auto horizontalConstraints = horizontalConstraintsForOutOfFlowBox(*outOfFlowBox);
-        auto verticalConstraints = verticalConstraintsForOutOfFlowBox(*outOfFlowBox);
-        // Borders and paddings are resolved against the containing block's content box like if this box was an in-flow box.
-        auto& outOfFlowRootDisplayBox = geometryForBox(*outOfFlowBox);
-        computeBorderAndPadding(*outOfFlowBox, Geometry::horizontalConstraintsForInFlow(outOfFlowRootDisplayBox));
+        auto outOfFlowHorizontalConstraints = horizontalConstraintsForLayoutBox(*outOfFlowBox);
+        auto horizontalConstraintsForBorderAndPadding = HorizontalConstraints { outOfFlowHorizontalConstraints.value.logicalLeft, outOfFlowHorizontalConstraints.borderAndPaddingSpecificWidth };
+        computeBorderAndPadding(*outOfFlowBox, horizontalConstraintsForBorderAndPadding);
+
+        auto horizontalConstraints = outOfFlowHorizontalConstraints.value;
         computeOutOfFlowHorizontalGeometry(*outOfFlowBox, horizontalConstraints);
-        if (!is<ContainerBox>(*outOfFlowBox) || !downcast<ContainerBox>(*outOfFlowBox).hasChild()) {
-            computeOutOfFlowVerticalGeometry(*outOfFlowBox, horizontalConstraints, verticalConstraints);
-            continue;
-        }
-
-        auto& outOfFlowRootContainer = downcast<ContainerBox>(*outOfFlowBox);
-        auto formattingContext = LayoutContext::createFormattingContext(outOfFlowRootContainer, layoutState());
-        if (outOfFlowRootContainer.hasInFlowOrFloatingChild())
-            formattingContext->layoutInFlowContent(invalidationState, Geometry::horizontalConstraintsForInFlow(outOfFlowRootDisplayBox), Geometry::verticalConstraintsForInFlow(outOfFlowRootDisplayBox));
-        computeOutOfFlowVerticalGeometry(outOfFlowRootContainer, horizontalConstraints, verticalConstraints);
-        formattingContext->layoutOutOfFlowContent(invalidationState, Geometry::horizontalConstraintsForInFlow(outOfFlowRootDisplayBox), Geometry::verticalConstraintsForInFlow(outOfFlowRootDisplayBox));
+        if (is<ContainerBox>(*outOfFlowBox)) {
+            auto& containerBox = downcast<ContainerBox>(*outOfFlowBox);
+            auto& containerDisplayBox = geometryForBox(containerBox);
+
+            if (containerBox.hasInFlowOrFloatingChild()) {
+                auto horizontalConstraintsForInFlowContent = Geometry::horizontalConstraintsForInFlow(containerDisplayBox);
+                auto verticalConstraintsForInFlowContent = Geometry::verticalConstraintsForInFlow(containerDisplayBox);
+                auto formattingContext = LayoutContext::createFormattingContext(containerBox, layoutState());
+                formattingContext->layoutInFlowContent(invalidationState, horizontalConstraintsForInFlowContent, verticalConstraintsForInFlowContent);
+            }
+            computeOutOfFlowVerticalGeometry(containerBox, horizontalConstraints, verticalConstraintsForLayoutBox(containerBox));
+            if (containerBox.hasChild()) {
+                auto horizontalConstraintsForOutOfFlowContent =  Geometry::horizontalConstraintsForOutOfFlow(containerDisplayBox);
+                auto verticalConstraintsForOutOfFlowContent = Geometry::verticalConstraintsForOutOfFlow(containerDisplayBox);
+                auto formattingContext = LayoutContext::createFormattingContext(containerBox, layoutState());
+                formattingContext->layoutOutOfFlowContent(invalidationState, horizontalConstraintsForOutOfFlowContent, verticalConstraintsForOutOfFlowContent);
+            }
+        } else
+            computeOutOfFlowVerticalGeometry(*outOfFlowBox, horizontalConstraints, verticalConstraintsForLayoutBox(*outOfFlowBox));
     }
     LOG_WITH_STREAM(FormattingContextLayout, stream << "End: layout out-of-flow content -> context: " << &layoutState() << " root: " << &root());

trunk/Source/WebCore/layout/FormattingContext.h

@@ -67 +67 @@
 
     virtual void layoutInFlowContent(InvalidationState&, const HorizontalConstraints&, const VerticalConstraints&) = 0;
-    void layoutOutOfFlowContent(InvalidationState&, const HorizontalConstraints&, const VerticalConstraints&);
+    void layoutOutOfFlowContent(InvalidationState&, const OutOfFlowHorizontalConstraints&, const VerticalConstraints&);
 
     struct IntrinsicWidthConstraints {
@@ -147 +147 @@
         LayoutUnit contentHeightForFormattingContextRoot(const Box&) const;
 
-        static HorizontalConstraints horizontalConstraintsForOutOfFlow(const Display::Box& containingBlockGeometry);
+        static OutOfFlowHorizontalConstraints horizontalConstraintsForOutOfFlow(const Display::Box& containingBlockGeometry);
         static VerticalConstraints verticalConstraintsForOutOfFlow(const Display::Box& containingBlockGeometry);
         static HorizontalConstraints horizontalConstraintsForInFlow(const Display::Box& containingBlockGeometry);

trunk/Source/WebCore/layout/FormattingContextGeometry.cpp

@@ -1102 +1102 @@
 }
 
-HorizontalConstraints FormattingContext::Geometry::horizontalConstraintsForOutOfFlow(const Display::Box& containingBlockGeometry)
-{
-    return HorizontalConstraints { containingBlockGeometry.paddingBoxLeft(), containingBlockGeometry.paddingBoxWidth() };
+OutOfFlowHorizontalConstraints FormattingContext::Geometry::horizontalConstraintsForOutOfFlow(const Display::Box& containingBlockGeometry)
+{
+    return OutOfFlowHorizontalConstraints {
+        HorizontalConstraints { containingBlockGeometry.paddingBoxLeft(), containingBlockGeometry.paddingBoxWidth() },
+        containingBlockGeometry.contentBoxWidth() };
 }
 

trunk/Source/WebCore/layout/LayoutContext.cpp

@@ -104 +104 @@
     // It also means that the formattingContextRoot has to have a valid/clean geometry at this point.
     {
-        auto horizontalConstraints = HorizontalConstraints { displayBox.paddingBoxLeft(), displayBox.paddingBoxWidth() };
+        auto horizontalConstraints = OutOfFlowHorizontalConstraints { HorizontalConstraints { displayBox.paddingBoxLeft(), displayBox.paddingBoxWidth() }, displayBox.contentBoxWidth() };
         auto verticalConstraints = VerticalConstraints { displayBox.paddingBoxTop(), displayBox.paddingBoxHeight() };
         formattingContext->layoutOutOfFlowContent(invalidationState, horizontalConstraints, verticalConstraints);

trunk/Source/WebCore/layout/LayoutUnits.h

@@ -158 +158 @@
 };
 
+struct OutOfFlowHorizontalConstraints {
+    HorizontalConstraints value;
+    // Borders and paddings are resolved against the containing block's content box as if the box was an in-flow box.
+    LayoutUnit borderAndPaddingSpecificWidth;
+};
+
 struct VerticalConstraints {
     LayoutUnit logicalTop;

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

@@ -127 +127 @@
             if (layoutBox.establishesFormattingContext()) {
                 if (is<ContainerBox>(layoutBox) && downcast<ContainerBox>(layoutBox).hasInFlowOrFloatingChild()) {
+                    auto& containerBox = downcast<ContainerBox>(layoutBox);
                     // Layout the inflow descendants of this formatting context root.
-                    precomputeVerticalPositionForFormattingRoot(floatingContext, layoutBox, horizontalConstraints, verticalConstraints);
-                    auto& rootDisplayBox = geometryForBox(layoutBox);
-                    auto horizontalConstraintsForFormattingContext = Geometry::horizontalConstraintsForInFlow(rootDisplayBox);
-                    auto verticalConstraintsForFormattingContext = Geometry::verticalConstraintsForInFlow(rootDisplayBox);
-                    LayoutContext::createFormattingContext(downcast<ContainerBox>(layoutBox), layoutState())->layoutInFlowContent(invalidationState, horizontalConstraintsForFormattingContext, verticalConstraintsForFormattingContext);
+                    precomputeVerticalPositionForFormattingRoot(floatingContext, containerBox, horizontalConstraints, verticalConstraints);
+                    auto& rootDisplayBox = geometryForBox(containerBox);
+                    auto horizontalConstraintsForInFlowContent = Geometry::horizontalConstraintsForInFlow(rootDisplayBox);
+                    auto verticalConstraintsForInFlowContent = Geometry::verticalConstraintsForInFlow(rootDisplayBox);
+                    LayoutContext::createFormattingContext(containerBox, layoutState())->layoutInFlowContent(invalidationState, horizontalConstraintsForInFlowContent, verticalConstraintsForInFlowContent);
                 }
                 break;
@@ -152 +153 @@
                 // Now that we computed the root's height, we can layout the out-of-flow descendants.
                 if (is<ContainerBox>(layoutBox) && downcast<ContainerBox>(layoutBox).hasChild()) {
-                    auto& rootDisplayBox = geometryForBox(layoutBox);
-                    auto horizontalConstraintsForOutOfFlow =  Geometry::horizontalConstraintsForOutOfFlow(rootDisplayBox);
-                    auto verticalConstraintsForOutOfFlow = Geometry::verticalConstraintsForOutOfFlow(rootDisplayBox);
-                    LayoutContext::createFormattingContext(downcast<ContainerBox>(layoutBox), layoutState())->layoutOutOfFlowContent(invalidationState, horizontalConstraintsForOutOfFlow, verticalConstraintsForOutOfFlow);
+                    auto& containerBox = downcast<ContainerBox>(layoutBox);
+                    auto& rootDisplayBox = geometryForBox(containerBox);
+                    auto horizontalConstraintsForOutOfFlowContent =  Geometry::horizontalConstraintsForOutOfFlow(rootDisplayBox);
+                    auto verticalConstraintsForOutOfFlowContent = Geometry::verticalConstraintsForOutOfFlow(rootDisplayBox);
+                    LayoutContext::createFormattingContext(containerBox, layoutState())->layoutOutOfFlowContent(invalidationState, horizontalConstraintsForOutOfFlowContent, verticalConstraintsForOutOfFlowContent);
                 }
             }

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

@@ -90 +90 @@
         if (layoutBox->isAtomicInlineLevelBox()) {
             // Inline-blocks, inline-tables and replaced elements (img, video) can be sized but not yet positioned.
-            computeBorderAndPadding(*layoutBox, horizontalConstraints);
-            computeWidthAndMargin(*layoutBox, horizontalConstraints);
-            auto createsFormattingContext = layoutBox->isInlineBlockBox() || layoutBox->isInlineTableBox();
-            auto hasInFlowOrFloatingChild = is<ContainerBox>(*layoutBox) && downcast<ContainerBox>(*layoutBox).hasInFlowOrFloatingChild();
-            if (createsFormattingContext && hasInFlowOrFloatingChild) {
-                auto formattingContext = LayoutContext::createFormattingContext(downcast<ContainerBox>(*layoutBox), layoutState());
-                formattingContext->layoutInFlowContent(invalidationState, horizontalConstraints, verticalConstraints);
-            }
-            computeHeightAndMargin(*layoutBox, horizontalConstraints);
-            if (createsFormattingContext && is<ContainerBox>(*layoutBox) && downcast<ContainerBox>(*layoutBox).hasChild()) {
-                auto& displayBox = geometryForBox(*layoutBox);
-                auto horizontalConstraintsForOutOfFlow = Geometry::horizontalConstraintsForOutOfFlow(displayBox);
-                auto verticalConstraintsForOutOfFlow = Geometry::verticalConstraintsForOutOfFlow(displayBox);
-                auto formattingContext = LayoutContext::createFormattingContext(downcast<ContainerBox>(*layoutBox), layoutState());
-                formattingContext->layoutOutOfFlowContent(invalidationState, horizontalConstraintsForOutOfFlow, verticalConstraintsForOutOfFlow);
+            if (layoutBox->establishesFormattingContext()) {
+                ASSERT(is<ContainerBox>(*layoutBox));
+                ASSERT(layoutBox->isInlineBlockBox() || layoutBox->isInlineTableBox());
+                auto& containerBox = downcast<ContainerBox>(*layoutBox);
+                computeBorderAndPadding(containerBox, horizontalConstraints);
+                computeWidthAndMargin(containerBox, horizontalConstraints);
+
+                auto& rootDisplayBox = geometryForBox(containerBox);
+                if (containerBox.hasInFlowOrFloatingChild()) {
+                    auto horizontalConstraintsForInFlowContent = Geometry::horizontalConstraintsForInFlow(rootDisplayBox);
+                    auto verticalConstraintsForInFlowContent = Geometry::verticalConstraintsForInFlow(rootDisplayBox);
+                    auto formattingContext = LayoutContext::createFormattingContext(containerBox, layoutState());
+                    formattingContext->layoutInFlowContent(invalidationState, horizontalConstraintsForInFlowContent, verticalConstraintsForInFlowContent);
+                }
+                computeHeightAndMargin(containerBox, horizontalConstraints);
+                if (containerBox.hasChild()) {
+                    auto horizontalConstraintsForOutOfFlow = Geometry::horizontalConstraintsForOutOfFlow(rootDisplayBox);
+                    auto verticalConstraintsForOutOfFlow = Geometry::verticalConstraintsForOutOfFlow(rootDisplayBox);
+                    auto formattingContext = LayoutContext::createFormattingContext(containerBox, layoutState());
+                    formattingContext->layoutOutOfFlowContent(invalidationState, horizontalConstraintsForOutOfFlow, verticalConstraintsForOutOfFlow);
+                }
+            } else {
+                // Replaced and other type of leaf atomic inline boxes.
+                computeBorderAndPadding(*layoutBox, horizontalConstraints);
+                computeWidthAndMargin(*layoutBox, horizontalConstraints);
+                computeHeightAndMargin(*layoutBox, horizontalConstraints);
             }
         } else if (layoutBox->isInlineBox()) {