Changeset 254977 in webkit

Timestamp:

Jan 23, 2020 8:15:15 AM (4 years ago)

Author:

Alan Bujtas

Message:

[LFC][IFC] Do not special case formatting root layout
​https://bugs.webkit.org/show_bug.cgi?id=206641
<rdar://problem/58823548>

Reviewed by Antti Koivisto.

Let's move out all the formatting context layout logic from layoutFormattingContextRoot.

• layout/inlineformatting/InlineFormattingContext.cpp:

(WebCore::Layout::InlineFormattingContext::layoutInFlowContent):
(WebCore::Layout::InlineFormattingContext::layoutFormattingContextRoot): Deleted.
(WebCore::Layout::InlineFormattingContext::computeHorizontalAndVerticalGeometry): Deleted.
(WebCore::Layout::InlineFormattingContext::computeWidthAndHeightForReplacedInlineBox): Deleted.

• layout/inlineformatting/InlineFormattingContext.h:
• layout/layouttree/LayoutBox.cpp:

(WebCore::Layout::Box::isInlineTableBox const):
(WebCore::Layout::Box::isInlineLevelBox const):

• layout/layouttree/LayoutBox.h:

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• layout/inlineformatting/InlineFormattingContext.cpp (modified) (3 diffs)
• layout/inlineformatting/InlineFormattingContext.h (modified) (1 diff)
• layout/layouttree/LayoutBox.cpp (modified) (2 diffs)
• layout/layouttree/LayoutBox.h (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2020-01-23  Zalan Bujtas  <zalan@apple.com>
+
+        [LFC][IFC] Do not special case formatting root layout
+        https://bugs.webkit.org/show_bug.cgi?id=206641
+        <rdar://problem/58823548>
+
+        Reviewed by Antti Koivisto.
+
+        Let's move out all the formatting context layout logic from layoutFormattingContextRoot.
+
+        * layout/inlineformatting/InlineFormattingContext.cpp:
+        (WebCore::Layout::InlineFormattingContext::layoutInFlowContent):
+        (WebCore::Layout::InlineFormattingContext::layoutFormattingContextRoot): Deleted.
+        (WebCore::Layout::InlineFormattingContext::computeHorizontalAndVerticalGeometry): Deleted.
+        (WebCore::Layout::InlineFormattingContext::computeWidthAndHeightForReplacedInlineBox): Deleted.
+        * layout/inlineformatting/InlineFormattingContext.h:
+        * layout/layouttree/LayoutBox.cpp:
+        (WebCore::Layout::Box::isInlineTableBox const):
+        (WebCore::Layout::Box::isInlineLevelBox const):
+        * layout/layouttree/LayoutBox.h:
+
 2020-01-23  Antti Koivisto  <antti@apple.com>
 

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

@@ -77 +77 @@
     // 2. Collect the inline items (flatten the the layout tree) and place them on lines in bidirectional order. 
     while (layoutBox) {
-        if (layoutBox->establishesFormattingContext())
-            layoutFormattingContextRoot(*layoutBox, invalidationState, horizontalConstraints, verticalConstraints);
-        else
-            computeHorizontalAndVerticalGeometry(*layoutBox, horizontalConstraints);
+        ASSERT(layoutBox->isInlineLevelBox());
+
+        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<Container>(*layoutBox) && downcast<Container>(*layoutBox).hasInFlowOrFloatingChild();
+            if (createsFormattingContext && hasInFlowOrFloatingChild) {
+                auto formattingContext = LayoutContext::createFormattingContext(downcast<Container>(*layoutBox), layoutState());
+                formattingContext->layoutInFlowContent(invalidationState, horizontalConstraints, verticalConstraints);
+            }
+            computeHeightAndMargin(*layoutBox, horizontalConstraints);
+            if (createsFormattingContext && is<Container>(*layoutBox) && downcast<Container>(*layoutBox).hasChild()) {
+                auto& displayBox = geometryForBox(*layoutBox);
+                auto horizontalConstraintsForOutOfFlow = Geometry::horizontalConstraintsForOutOfFlow(displayBox);
+                auto verticalConstraintsForOutOfFlow = Geometry::verticalConstraintsForOutOfFlow(displayBox);
+                auto formattingContext = LayoutContext::createFormattingContext(downcast<Container>(*layoutBox), layoutState());
+                formattingContext->layoutOutOfFlowContent(invalidationState, horizontalConstraintsForOutOfFlow, verticalConstraintsForOutOfFlow);
+            }
+        } else if (layoutBox->isInlineBox()) {
+            if (layoutBox->isAnonymous() || layoutBox->isLineBreakBox()) {
+                // Text wrapper boxes are anonymous inline level boxes. Their computed border/padding/margins are 0.
+                auto& displayBox = formattingState().displayBox(*layoutBox);
+                displayBox.setVerticalMargin({ { }, { } });
+                displayBox.setHorizontalMargin({ });
+                displayBox.setBorder({ { }, { } });
+                displayBox.setPadding({ });
+            } else {
+                // Inline boxes (<span>) can't get sized/positioned yet. At this point we can only compute their margins, borders and paddings.
+                computeBorderAndPadding(*layoutBox, horizontalConstraints);
+                computeHorizontalMargin(*layoutBox, horizontalConstraints);
+                formattingState().displayBox(*layoutBox).setVerticalMargin({ { }, { } });
+            }
+        } else
+            ASSERT_NOT_REACHED();
+
         layoutBox = nextInPreOrder(*layoutBox, root());
     }
@@ -127 +160 @@
         ASSERT(lineLogicalTop < inifitePoint.y);
     }
-}
-
-void InlineFormattingContext::layoutFormattingContextRoot(const Box& formattingContextRoot, InvalidationState& invalidationState, const HorizontalConstraints& horizontalConstraints, const VerticalConstraints& verticalConstraints)
-{
-    ASSERT(formattingContextRoot.isFloatingPositioned() || formattingContextRoot.isInlineBlockBox());
-
-    computeBorderAndPadding(formattingContextRoot, horizontalConstraints);
-    computeWidthAndMargin(formattingContextRoot, horizontalConstraints);
-    if (!is<Container>(formattingContextRoot) || !downcast<Container>(formattingContextRoot).hasChild()) {
-        computeHeightAndMargin(formattingContextRoot, horizontalConstraints);
-        return;
-    }
-    // Swich over to the new formatting context (the one that the root creates).
-    auto& rootContainer = downcast<Container>(formattingContextRoot);
-    auto formattingContext = LayoutContext::createFormattingContext(rootContainer, layoutState());
-    if (rootContainer.hasInFlowOrFloatingChild())
-        formattingContext->layoutInFlowContent(invalidationState, horizontalConstraints, verticalConstraints);
-    // Come back and finalize the root's height and margin.
-    computeHeightAndMargin(rootContainer, horizontalConstraints);
-    // Now that we computed the root's height, we can go back and layout the out-of-flow content.
-    if (rootContainer.hasChild()) {
-        auto& rootContainerDisplayBox = geometryForBox(rootContainer);
-        auto horizontalConstraintsForOutOfFlow = Geometry::horizontalConstraintsForOutOfFlow(rootContainerDisplayBox);
-        auto verticalConstraintsForOutOfFlow = Geometry::verticalConstraintsForOutOfFlow(rootContainerDisplayBox);
-        formattingContext->layoutOutOfFlowContent(invalidationState, horizontalConstraintsForOutOfFlow, verticalConstraintsForOutOfFlow);
-    }
-}
-
-void InlineFormattingContext::computeHorizontalAndVerticalGeometry(const Box& layoutBox, const HorizontalConstraints& horizontalConstraints)
-{
-    if (layoutBox.isInlineBox() && !layoutBox.isAnonymous()) {
-        // Inline boxes (<span>) can't get sized/positioned yet. At this point we can only compute their margins, borders and paddings.
-        computeHorizontalMargin(layoutBox, horizontalConstraints);
-        computeBorderAndPadding(layoutBox, horizontalConstraints);
-        // Inline containers have 0 computed vertical margins.
-        formattingState().displayBox(layoutBox).setVerticalMargin({ { }, { } });
-        return;
-    }
-
-    if (layoutBox.isReplaced()) {
-        // Replaced elements (img, video) can be sized but not yet positioned.
-        computeBorderAndPadding(layoutBox, horizontalConstraints);
-        computeWidthAndMargin(layoutBox, horizontalConstraints);
-        computeHeightAndMargin(layoutBox, horizontalConstraints);
-        return;
-    }
-
-    // These are actual text boxes. No margins, borders or paddings.
-    ASSERT(layoutBox.isAnonymous() || layoutBox.isLineBreakBox());
-    auto& displayBox = formattingState().displayBox(layoutBox);
-
-    displayBox.setVerticalMargin({ { }, { } });
-    displayBox.setHorizontalMargin({ });
-    displayBox.setBorder({ { }, { } });
-    displayBox.setPadding({ });
 }
 
@@ -317 +295 @@
     displayBox.setContentBoxHeight(contentHeightAndMargin.contentHeight);
     displayBox.setVerticalMargin({ contentHeightAndMargin.nonCollapsedMargin, { } });
-}
-
-void InlineFormattingContext::computeWidthAndHeightForReplacedInlineBox(const Box& layoutBox, const HorizontalConstraints& horizontalConstraints)
-{
-    ASSERT(!layoutBox.isContainer());
-    ASSERT(!layoutBox.establishesFormattingContext());
-    ASSERT(layoutBox.replaced());
-
-    computeBorderAndPadding(layoutBox, horizontalConstraints);
-    computeWidthAndMargin(layoutBox, horizontalConstraints);
-    computeHeightAndMargin(layoutBox, horizontalConstraints);
 }
 

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

@@ -79 +79 @@
 
     void lineLayout(InlineItems&, LineLayoutContext::InlineItemRange, const HorizontalConstraints&, const VerticalConstraints&);
-    void layoutFormattingContextRoot(const Box&, InvalidationState&, const HorizontalConstraints&, const VerticalConstraints&);
-    void computeHorizontalAndVerticalGeometry(const Box&, const HorizontalConstraints&);
 
     void computeIntrinsicWidthForFormattingRoot(const Box&, const HorizontalConstraints&);
-    void computeWidthAndHeightForReplacedInlineBox(const Box&, const HorizontalConstraints&);
     InlineLayoutUnit computedIntrinsicWidthForConstraint(const HorizontalConstraints&) const;
 

trunk/Source/WebCore/layout/layouttree/LayoutBox.cpp

@@ -295 +295 @@
 }
 
+bool Box::isInlineTableBox() const
+{
+    return m_style.display() == DisplayType::InlineTable;
+}
+
 bool Box::isBlockLevelBox() const
 {
@@ -306 +311 @@
     // Inline level elements generate inline level boxes.
     auto display = m_style.display();
-    return display == DisplayType::Inline || isInlineBlockBox() || display == DisplayType::InlineTable;
+    return display == DisplayType::Inline || isInlineBlockBox() || isInlineTableBox();
 }
 

trunk/Source/WebCore/layout/layouttree/LayoutBox.h

@@ -113 +113 @@
     bool isAtomicInlineLevelBox() const;
     bool isInlineBlockBox() const;
+    bool isInlineTableBox() const;
     bool isBlockContainerBox() const;
     bool isInitialContainingBlock() const;