Changeset 248290 in webkit

Timestamp:

Aug 5, 2019, 10:20:09 PM (7 years ago)

Author:

Alan Bujtas

Message:

[LFC] Remove out-of-flow descendants from Container
​https://bugs.webkit.org/show_bug.cgi?id=200430
<rdar://problem/53923980>

Reviewed by Antti Koivisto.

The out-of-flow descendant list is the last "formatting context type" bit in the layout tree.
Let's cached them in the FormattingStates instead for now.

• layout/FormattingContext.cpp:

(WebCore::Layout::FormattingContext::layoutOutOfFlowDescendants const):

• layout/FormattingContext.h:
• layout/FormattingState.h:

(WebCore::Layout::FormattingState::addOutOfFlowBox):
(WebCore::Layout::FormattingState::outOfFlowBoxes const):

• layout/LayoutState.cpp:

(WebCore::Layout::LayoutState::layoutFormattingContextSubtree):
(WebCore::Layout::LayoutState::createFormattingStateForFormattingRootIfNeeded):
(WebCore::Layout::LayoutState::run):

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

(WebCore::Layout::BlockFormattingContext::layoutFormattingContextRoot const):

• layout/inlineformatting/InlineFormattingContext.cpp:

(WebCore::Layout::InlineFormattingContext::layoutFormattingContextRoot const):

• layout/layouttree/LayoutBox.h:
• layout/layouttree/LayoutContainer.cpp:

(WebCore::Layout::Container::addOutOfFlowDescendant): Deleted.

• layout/layouttree/LayoutContainer.h:
• layout/layouttree/LayoutTreeBuilder.cpp:

(WebCore::Layout::TreeBuilder::createLayoutTree):

• page/FrameViewLayoutContext.cpp:

(WebCore::layoutUsingFormattingContext):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• layout/FormattingContext.cpp (modified) (1 diff)
• layout/FormattingContext.h (modified) (1 diff)
• layout/FormattingState.h (modified) (3 diffs)
• layout/LayoutState.cpp (modified) (4 diffs)
• layout/LayoutState.h (modified) (3 diffs)
• layout/blockformatting/BlockFormattingContext.cpp (modified) (2 diffs)
• layout/inlineformatting/InlineFormattingContext.cpp (modified) (1 diff)
• layout/layouttree/LayoutBox.h (modified) (1 diff)
• layout/layouttree/LayoutContainer.cpp (modified) (1 diff)
• layout/layouttree/LayoutContainer.h (modified) (2 diffs)
• layout/layouttree/LayoutTreeBuilder.cpp (modified) (1 diff)
• page/FrameViewLayoutContext.cpp (modified) (2 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2019-08-05  Zalan Bujtas  <zalan@apple.com>
+
+        [LFC] Remove out-of-flow descendants from Container
+        https://bugs.webkit.org/show_bug.cgi?id=200430
+        <rdar://problem/53923980>
+
+        Reviewed by Antti Koivisto.
+
+        The out-of-flow descendant list is the last "formatting context type" bit in the layout tree.
+        Let's cached them in the FormattingStates instead for now. 
+
+        * layout/FormattingContext.cpp:
+        (WebCore::Layout::FormattingContext::layoutOutOfFlowDescendants const):
+        * layout/FormattingContext.h:
+        * layout/FormattingState.h:
+        (WebCore::Layout::FormattingState::addOutOfFlowBox):
+        (WebCore::Layout::FormattingState::outOfFlowBoxes const):
+        * layout/LayoutState.cpp:
+        (WebCore::Layout::LayoutState::layoutFormattingContextSubtree):
+        (WebCore::Layout::LayoutState::createFormattingStateForFormattingRootIfNeeded):
+        (WebCore::Layout::LayoutState::run):
+        * layout/LayoutState.h:
+        * layout/blockformatting/BlockFormattingContext.cpp:
+        (WebCore::Layout::BlockFormattingContext::layoutFormattingContextRoot const):
+        * layout/inlineformatting/InlineFormattingContext.cpp:
+        (WebCore::Layout::InlineFormattingContext::layoutFormattingContextRoot const):
+        * layout/layouttree/LayoutBox.h:
+        * layout/layouttree/LayoutContainer.cpp:
+        (WebCore::Layout::Container::addOutOfFlowDescendant): Deleted.
+        * layout/layouttree/LayoutContainer.h:
+        * layout/layouttree/LayoutTreeBuilder.cpp:
+        (WebCore::Layout::TreeBuilder::createLayoutTree):
+        * page/FrameViewLayoutContext.cpp:
+        (WebCore::layoutUsingFormattingContext):
+
 2019-08-05  Devin Rousso  <drousso@apple.com>
 

trunk/Source/WebCore/layout/FormattingContext.cpp

@@ -134 +134 @@
 }
 
-void FormattingContext::layoutOutOfFlowDescendants(const Box& layoutBox) const
-{
-    if (!is<Container>(layoutBox))
-        return;
-
-    auto& container = downcast<Container>(layoutBox);
-    if (!container.hasChild())
-        return;
-
-    auto& layoutState = this->layoutState();
-    LOG_WITH_STREAM(FormattingContextLayout, stream << "Start: layout out-of-flow descendants -> context: " << &layoutState << " root: " << &root());
-
-    for (auto& outOfFlowBox : container.outOfFlowDescendants()) {
-        auto& layoutBox = *outOfFlowBox;
-
-        ASSERT(layoutBox.establishesFormattingContext());
-
-        computeBorderAndPadding(layoutBox);
-        computeOutOfFlowHorizontalGeometry(layoutBox);
-
-        layoutState.createFormattingContext(layoutBox)->layout();
-
-        computeOutOfFlowVerticalGeometry(layoutBox);
-        layoutOutOfFlowDescendants(layoutBox);
-    }
-    LOG_WITH_STREAM(FormattingContextLayout, stream << "End: layout out-of-flow descendants -> context: " << &layoutState << " root: " << &root());
+void FormattingContext::layoutOutOfFlowDescendants() const
+{
+    LOG_WITH_STREAM(FormattingContextLayout, stream << "Start: layout out-of-flow descendants -> context: " << &layoutState() << " root: " << &root());
+
+    for (auto& outOfFlowBox : formattingState().outOfFlowBoxes()) {
+        ASSERT(outOfFlowBox->establishesFormattingContext());
+
+        computeBorderAndPadding(*outOfFlowBox);
+        computeOutOfFlowHorizontalGeometry(*outOfFlowBox);
+
+        auto formattingContext = layoutState().createFormattingContext(*outOfFlowBox);
+        formattingContext->layout();
+
+        computeOutOfFlowVerticalGeometry(*outOfFlowBox);
+        formattingContext->layoutOutOfFlowDescendants();
+    }
+    LOG_WITH_STREAM(FormattingContextLayout, stream << "End: layout out-of-flow descendants -> context: " << &layoutState() << " root: " << &root());
 }
 

trunk/Source/WebCore/layout/FormattingContext.h

@@ -51 +51 @@
 
     virtual void layout() const = 0;
-    void layoutOutOfFlowDescendants(const Box&) const;
+    void layoutOutOfFlowDescendants() const;
 
     struct IntrinsicWidthConstraints {

trunk/Source/WebCore/layout/FormattingState.h

@@ -34 +34 @@
 #include "LayoutUnit.h"
 #include <wtf/IsoMalloc.h>
+#include <wtf/WeakPtr.h>
 
 namespace WebCore {
@@ -65 +66 @@
     LayoutState& layoutState() const { return m_layoutState; }
 
+    // Since we layout the out-of-flow boxes at the end of the formatting context layout, it's okay to store them in the formatting state -as opposed to the containing block level.
+    using OutOfFlowBoxList = Vector<WeakPtr<const Box>>;
+    void addOutOfFlowBox(const Box& outOfFlowBox) { m_outOfFlowBoxes.append(makeWeakPtr(outOfFlowBox)); }
+    void removeOutOfFlowBox(const Box&);
+    const OutOfFlowBoxList& outOfFlowBoxes() const { return m_outOfFlowBoxes; }
+
 protected:
     enum class Type { Block, Inline, Table };
@@ -74 +81 @@
     HashMap<const Box*, FormattingContext::IntrinsicWidthConstraints> m_intrinsicWidthConstraintsForBoxes;
     Optional<FormattingContext::IntrinsicWidthConstraints> m_intrinsicWidthConstraints;
+    // FIXME: This needs WeakListHashSet
+    OutOfFlowBoxList m_outOfFlowBoxes;
     Type m_type;
 };

trunk/Source/WebCore/layout/LayoutState.cpp

@@ -39 +39 @@
 #include "LayoutBox.h"
 #include "LayoutContainer.h"
+#include "LayoutTreeBuilder.h"
+#include "RenderView.h"
 #include "TableFormattingContext.h"
 #include "TableFormattingState.h"
@@ -81 +83 @@
     auto formattingContext = createFormattingContext(layoutRoot);
     formattingContext->layout();
-    formattingContext->layoutOutOfFlowDescendants(layoutRoot);
+    formattingContext->layoutOutOfFlowDescendants();
 }
 
@@ -138 +140 @@
             // Otherwise, the formatting context inherits the floats from the parent formatting context.
             // Find the formatting state in which this formatting root lives, not the one it creates and use its floating state.
-            return std::make_unique<InlineFormattingState>(formattingStateForBox(formattingRoot).floatingState(), *this);
+            auto& parentFormattingState = createFormattingStateForFormattingRootIfNeeded(formattingRoot.formattingContextRoot()); 
+            auto& parentFloatingState = parentFormattingState.floatingState();
+            return std::make_unique<InlineFormattingState>(parentFloatingState, *this);
         }).iterator->value;
     }
@@ -183 +187 @@
 }
 
+void LayoutState::run(const RenderView& renderView)
+{
+    auto initialContainingBlock = TreeBuilder::createLayoutTree(renderView);
+    auto layoutState = LayoutState(*initialContainingBlock);
+    // Not efficient, but this is temporary anyway.
+    // Collect the out-of-flow descendants at the formatting root level (as opposed to at the containing block level, though they might be the same).
+    for (auto& descendant : descendantsOfType<Box>(*initialContainingBlock)) {
+        if (!descendant.isOutOfFlowPositioned())
+            continue;
+        auto& formattingState = layoutState.createFormattingStateForFormattingRootIfNeeded(descendant.formattingContextRoot());
+        formattingState.addOutOfFlowBox(descendant);
+    }
+    auto quirksMode = [&] {
+        auto& document = renderView.document();
+        if (document.inLimitedQuirksMode())
+            return QuirksMode::Limited;
+        if (document.inQuirksMode())
+            return QuirksMode::Yes;
+        return QuirksMode::No;
+    };
+    layoutState.setQuirksMode(quirksMode());
+    layoutState.updateLayout();
+    layoutState.verifyAndOutputMismatchingLayoutTree(renderView);
+}
+
 }
 }

trunk/Source/WebCore/layout/LayoutState.h

@@ -28 +28 @@
 #if ENABLE(LAYOUT_FORMATTING_CONTEXT)
 
+#include "LayoutContainer.h"
 #include <wtf/HashMap.h>
 #include <wtf/HashSet.h>
@@ -48 +49 @@
 enum class StyleDiff;
 class Box;
-class Container;
 class FormattingContext;
 class FormattingState;
@@ -62 +62 @@
 public:
     LayoutState(const Container& initialContainingBlock);
+
+    // FIXME: This is a temporary entry point for LFC layout.
+    static void run(const RenderView&);
 
     void updateLayout();

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

@@ -173 +173 @@
     LOG_WITH_STREAM(FormattingContextLayout, stream << "[Compute] -> [Height][Margin] -> for layoutBox(" << &layoutBox << ")");
     computeHeightAndMargin(layoutBox);
+    // Now that we computed the root's height, we can go back and layout the out-of-flow descedants (if any).
+    formattingContext->layoutOutOfFlowDescendants();
 
     // Float related final positioning.
@@ -180 +182 @@
     } else if (layoutBox.establishesBlockFormattingContext())
         computePositionToAvoidFloats(floatingContext, layoutBox);
-
-    // Now that we computed the root's height, we can go back and layout the out-of-flow descedants (if any).
-    formattingContext->layoutOutOfFlowDescendants(layoutBox);
 }
 

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

@@ -250 +250 @@
     computeHeightAndMargin(root);
     // Now that we computed the root's height, we can go back and layout the out-of-flow descedants (if any).
-    formattingContext->layoutOutOfFlowDescendants(root);
+    formattingContext->layoutOutOfFlowDescendants();
 }
 

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

@@ -98 +98 @@
 
     const Container* containingBlock() const;
-    virtual const Container& formattingContextRoot() const;
+    const Container& formattingContextRoot() const;
     const Container& initialContainingBlock() const;
 

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

@@ -92 +92 @@
 }
 
-void Container::addOutOfFlowDescendant(const Box& outOfFlowBox)
-{
-    // Since we layout the out-of-flow boxes at the end of the formatting context layout,
-    // it's okay to store them at the formatting context root level -as opposed to the containing block level.
-    ASSERT(establishesFormattingContext());
-    m_outOfFlowDescendants.append(makeWeakPtr(outOfFlowBox));
-}
-
 }
 }

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

@@ -30 +30 @@
 #include "LayoutBox.h"
 #include <wtf/IsoMalloc.h>
-#include <wtf/WeakPtr.h>
 
 namespace WebCore {
@@ -54 +53 @@
     bool hasInFlowOrFloatingChild() const { return firstInFlowOrFloatingChild(); }
 
-    const Vector<WeakPtr<const Box>>& outOfFlowDescendants() const { return m_outOfFlowDescendants; }
-
     void setFirstChild(Box&);
     void setLastChild(Box&);
-    void addOutOfFlowDescendant(const Box&);
 
 private:
     Box* m_firstChild { nullptr };
     Box* m_lastChild { nullptr };
-    Vector<WeakPtr<const Box>> m_outOfFlowDescendants;
 };
 

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

@@ -76 +76 @@
     std::unique_ptr<Container> initialContainingBlock(new Container(WTF::nullopt, WTFMove(style)));
     TreeBuilder::createSubTree(renderView, *initialContainingBlock);
-
-    // Not efficient, but this is temporary anyway.
-    // Collect the out-of-flow descendants at the formatting root level (as opposed to at the containing block level, though they might be the same).
-    for (auto& descendant : descendantsOfType<Box>(*initialContainingBlock)) {
-        if (!descendant.isOutOfFlowPositioned())
-            continue;
-        const_cast<Container&>(descendant.formattingContextRoot()).addOutOfFlowDescendant(descendant);
-    }
-
     return initialContainingBlock;
 }

trunk/Source/WebCore/page/FrameViewLayoutContext.cpp

@@ -40 +40 @@
 #include "ScriptDisallowedScope.h"
 #include "Settings.h"
-
 #if ENABLE(LAYOUT_FORMATTING_CONTEXT)
-#include "FormattingState.h"
-#include "LayoutContainer.h"
 #include "LayoutState.h"
-#include "LayoutTreeBuilder.h"
 #endif
 
@@ -59 +55 @@
     if (!RuntimeEnabledFeatures::sharedFeatures().layoutFormattingContextEnabled())
         return;
-    auto initialContainingBlock = Layout::TreeBuilder::createLayoutTree(renderView);
-    auto layoutState = std::make_unique<Layout::LayoutState>(*initialContainingBlock);
-    auto quirksMode = Layout::LayoutState::QuirksMode::No;
-    if (renderView.document().inLimitedQuirksMode())
-        quirksMode = Layout::LayoutState::QuirksMode::Limited;
-    else if (renderView.document().inQuirksMode())
-        quirksMode = Layout::LayoutState::QuirksMode::Yes;
-    layoutState->setQuirksMode(quirksMode);
-    layoutState->updateLayout();
-    layoutState->verifyAndOutputMismatchingLayoutTree(renderView);
+    Layout::LayoutState::run(renderView);
 } 
 #endif