Changeset 249437 in webkit

Timestamp:

Sep 3, 2019 12:21:48 PM (5 years ago)

Author:

Alan Bujtas

Message:

[LFC][Floats] Do not pass FloatingState to FloatAvoider/FloatBox
​https://bugs.webkit.org/show_bug.cgi?id=201405
<rdar://problem/54956381>

Reviewed by Antti Koivisto.

This is in preparation for transitioning the floating codebase to use the formatting context for
retrieving display boxes. Now FloatAvoiders/FloatBoxes don't need the FloatingState to compute absolute display boxes.

• layout/floats/FloatAvoider.cpp:

(WebCore::Layout::FloatAvoider::FloatAvoider):
(WebCore::Layout::FloatAvoider::setHorizontalConstraints):
(WebCore::Layout::FloatAvoider::initialHorizontalPosition const):
(WebCore::Layout::FloatAvoider::overflowsContainingBlock const):
(WebCore::Layout::FloatAvoider::rectInContainingBlock const):

• layout/floats/FloatAvoider.h:

(WebCore::Layout::FloatAvoider::floatingState const): Deleted.

• layout/floats/FloatBox.cpp:

(WebCore::Layout::FloatBox::FloatBox):
(WebCore::Layout::FloatBox::initialVerticalPosition const):

• layout/floats/FloatBox.h:
• layout/floats/FloatingContext.cpp:

(WebCore::Layout::mapToFormattingContextRoot):
(WebCore::Layout::FloatingContext::positionForFloat const):
(WebCore::Layout::FloatingContext::positionForFormattingContextRoot const):

• platform/graphics/LayoutPoint.h:

(WebCore::LayoutPoint::isZero const):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• layout/floats/FloatAvoider.cpp (modified) (5 diffs)
• layout/floats/FloatAvoider.h (modified) (3 diffs)
• layout/floats/FloatBox.cpp (modified) (2 diffs)
• layout/floats/FloatBox.h (modified) (2 diffs)
• layout/floats/FloatingContext.cpp (modified) (3 diffs)
• platform/graphics/LayoutPoint.h (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2019-09-03  Zalan Bujtas  <zalan@apple.com>
+
+        [LFC][Floats] Do not pass FloatingState to FloatAvoider/FloatBox
+        https://bugs.webkit.org/show_bug.cgi?id=201405
+        <rdar://problem/54956381>
+
+        Reviewed by Antti Koivisto.
+
+        This is in preparation for transitioning the floating codebase to use the formatting context for
+        retrieving display boxes. Now FloatAvoiders/FloatBoxes don't need the FloatingState to compute absolute display boxes.
+
+        * layout/floats/FloatAvoider.cpp:
+        (WebCore::Layout::FloatAvoider::FloatAvoider):
+        (WebCore::Layout::FloatAvoider::setHorizontalConstraints):
+        (WebCore::Layout::FloatAvoider::initialHorizontalPosition const):
+        (WebCore::Layout::FloatAvoider::overflowsContainingBlock const):
+        (WebCore::Layout::FloatAvoider::rectInContainingBlock const):
+        * layout/floats/FloatAvoider.h:
+        (WebCore::Layout::FloatAvoider::floatingState const): Deleted.
+        * layout/floats/FloatBox.cpp:
+        (WebCore::Layout::FloatBox::FloatBox):
+        (WebCore::Layout::FloatBox::initialVerticalPosition const):
+        * layout/floats/FloatBox.h:
+        * layout/floats/FloatingContext.cpp:
+        (WebCore::Layout::mapToFormattingContextRoot):
+        (WebCore::Layout::FloatingContext::positionForFloat const):
+        (WebCore::Layout::FloatingContext::positionForFormattingContextRoot const):
+        * platform/graphics/LayoutPoint.h:
+        (WebCore::LayoutPoint::isZero const):
+
 2019-09-03  Jiewen Tan  <jiewen_tan@apple.com>
 

trunk/Source/WebCore/layout/floats/FloatAvoider.cpp

@@ -39 +39 @@
 WTF_MAKE_ISO_ALLOCATED_IMPL(FloatAvoider);
 
-FloatAvoider::FloatAvoider(const Box& layoutBox, const FloatingState& floatingState, const LayoutState& layoutState)
+FloatAvoider::FloatAvoider(const Box& layoutBox, Display::Box absoluteDisplayBox, LayoutPoint containingBlockAbsoluteTopLeft, HorizontalEdges containingBlockAbsoluteContentBox)
     : m_layoutBox(makeWeakPtr(layoutBox))
-    , m_floatingState(floatingState)
-    , m_absoluteDisplayBox(FormattingContext::mapBoxToAncestor(layoutState, layoutBox, downcast<Container>(floatingState.root())))
-    , m_containingBlockAbsoluteDisplayBox(layoutBox.containingBlock() == &floatingState.root() ? Display::Box(layoutState.displayBoxForLayoutBox(*layoutBox.containingBlock())) : FormattingContext::mapBoxToAncestor(layoutState, *layoutBox.containingBlock(), downcast<Container>(floatingState.root())))
+    , m_absoluteDisplayBox(absoluteDisplayBox)
+    , m_containingBlockAbsoluteTopLeft(containingBlockAbsoluteTopLeft)
+    , m_containingBlockAbsoluteContentBox(containingBlockAbsoluteContentBox)
 {
     ASSERT(m_layoutBox->establishesBlockFormattingContext());
@@ -60 +60 @@
         // Horizontal position is constrained by the containing block's content box.
         // Compute the horizontal position for the new floating by taking both the contining block and the current left/right floats into account.
-        auto containingBlockContentBoxLeft = m_containingBlockAbsoluteDisplayBox.left() + m_containingBlockAbsoluteDisplayBox.contentBoxLeft();
         if (isLeftAligned())
-            return std::max<PositionInContextRoot>({ containingBlockContentBoxLeft + marginStart() }, left);
+            return std::max<PositionInContextRoot>({ m_containingBlockAbsoluteContentBox.left + marginStart() }, left);
 
         // Make sure it does not overflow the containing block on the right.
-        auto containingBlockContentBoxRight = containingBlockContentBoxLeft + m_containingBlockAbsoluteDisplayBox.contentBoxWidth();
-        return std::min<PositionInContextRoot>(left, { containingBlockContentBoxRight - marginBoxWidth() + marginStart() });
+        return std::min<PositionInContextRoot>(left, { m_containingBlockAbsoluteContentBox.right - marginBoxWidth() + marginStart() });
     };
 
@@ -91 +89 @@
 {
     // Align the box with the containing block's content box.
-    auto containingBlockContentBoxLeft = m_containingBlockAbsoluteDisplayBox.left() + m_containingBlockAbsoluteDisplayBox.contentBoxLeft();
-    auto containingBlockContentBoxRight = containingBlockContentBoxLeft + m_containingBlockAbsoluteDisplayBox.contentBoxWidth();
-
-    auto left = isLeftAligned() ? containingBlockContentBoxLeft : containingBlockContentBoxRight - marginBoxWidth();
+    auto left = isLeftAligned() ? m_containingBlockAbsoluteContentBox.left : m_containingBlockAbsoluteContentBox.right - marginBoxWidth();
     left += marginStart();
-
     return { left };
 }
@@ -102 +96 @@
 bool FloatAvoider::overflowsContainingBlock() const
 {
-    auto containingBlockContentBoxLeft = m_containingBlockAbsoluteDisplayBox.left() + m_containingBlockAbsoluteDisplayBox.contentBoxLeft();
     auto left = displayBox().left() - marginStart();
-
-    if (containingBlockContentBoxLeft > left)
+    if (m_containingBlockAbsoluteContentBox.left > left)
         return true;
 
-    auto containingBlockContentBoxRight = containingBlockContentBoxLeft + m_containingBlockAbsoluteDisplayBox.contentBoxWidth();
     auto right = displayBox().right() + marginEnd();
-
-    return containingBlockContentBoxRight < right;
+    return m_containingBlockAbsoluteContentBox.right < right;
 }
 
@@ -117 +107 @@
 {
     // From formatting root coordinate system back to containing block's.
-    if (layoutBox().containingBlock() == &floatingState().root())
+    if (m_containingBlockAbsoluteTopLeft.isZero())
         return m_absoluteDisplayBox.rect();
 
     return {
-        m_absoluteDisplayBox.top() - m_containingBlockAbsoluteDisplayBox.top(),
-        m_absoluteDisplayBox.left() - m_containingBlockAbsoluteDisplayBox.left(),
+        m_absoluteDisplayBox.top() - m_containingBlockAbsoluteTopLeft.y(),
+        m_absoluteDisplayBox.left() - m_containingBlockAbsoluteTopLeft.x(),
         m_absoluteDisplayBox.width(),
         m_absoluteDisplayBox.height()

trunk/Source/WebCore/layout/floats/FloatAvoider.h

@@ -44 +44 @@
     WTF_MAKE_ISO_ALLOCATED(FloatAvoider);
 public:
-    FloatAvoider(const Box&, const FloatingState&, const LayoutState&);
+    FloatAvoider(const Box&, Display::Box absoluteDisplayBox, LayoutPoint containingBlockAbsoluteTopLeft, HorizontalEdges containingBlockAbsoluteContentBox);
     virtual ~FloatAvoider() = default;
 
@@ -76 +76 @@
     LayoutUnit marginBoxWidth() const { return marginStart() + displayBox().width() + marginEnd(); }
 
-    const FloatingState& floatingState() const { return m_floatingState; }
     const Box& layoutBox() const { return *m_layoutBox; }
     const Display::Box& displayBox() const { return m_absoluteDisplayBox; }
@@ -83 +82 @@
 private:
     WeakPtr<const Box> m_layoutBox;
-    const FloatingState& m_floatingState;
+    // These coordinate values are relative to the formatting root's border box.
     Display::Box m_absoluteDisplayBox;
-    Display::Box m_containingBlockAbsoluteDisplayBox;
+    LayoutPoint m_containingBlockAbsoluteTopLeft;
+    HorizontalEdges m_containingBlockAbsoluteContentBox;
 };
 

trunk/Source/WebCore/layout/floats/FloatBox.cpp

@@ -36 +36 @@
 WTF_MAKE_ISO_ALLOCATED_IMPL(FloatBox);
 
-FloatBox::FloatBox(const Box& layoutBox, const FloatingState& floatingState, const LayoutState& layoutState)
-    : FloatAvoider(layoutBox, floatingState, layoutState)
+FloatBox::FloatBox(const Box& layoutBox, Display::Box absoluteDisplayBox, LayoutPoint containingBlockAbsoluteTopLeft, HorizontalEdges containingBlockAbsoluteContentBox, Optional<LayoutUnit> previousFloatAbsoluteTop)
+    : FloatAvoider(layoutBox, absoluteDisplayBox, containingBlockAbsoluteTopLeft, containingBlockAbsoluteContentBox)
 {
-    displayBox().setTopLeft({ initialHorizontalPosition(), initialVerticalPosition() });
+    displayBox().setTopLeft({ initialHorizontalPosition(), initialVerticalPosition(previousFloatAbsoluteTop) });
 }
 
@@ -61 +61 @@
 }
 
-PositionInContextRoot FloatBox::initialVerticalPosition() const
+PositionInContextRoot FloatBox::initialVerticalPosition(Optional<LayoutUnit> previousFloatAbsoluteTop) const
 {
     // Incoming float cannot be placed higher than existing floats (margin box of the last float).
     // Take the static position (where the box would go if it wasn't floating) and adjust it with the last float.
     auto top = displayBox().top() - marginBefore();
-    if (auto lastFloat = floatingState().last())
-        top = std::max(top, lastFloat->rectWithMargin().top());
+    if (previousFloatAbsoluteTop)
+        top = std::max(top, *previousFloatAbsoluteTop);
     top += marginBefore();
 

trunk/Source/WebCore/layout/floats/FloatBox.h

@@ -42 +42 @@
     WTF_MAKE_ISO_ALLOCATED(FloatBox);
 public:
-    FloatBox(const Box&, const FloatingState&, const LayoutState&);
+    FloatBox(const Box&, Display::Box absoluteDisplayBox, LayoutPoint containingBlockAbsoluteTopLeft, HorizontalEdges containingBlockAbsoluteContentBox, Optional<LayoutUnit> previousFloatAbsoluteTop);
 
     Display::Rect rect() const final;
@@ -52 +52 @@
     PositionInContextRoot verticalPositionCandidate(PositionInContextRoot) final;
 
-    PositionInContextRoot initialVerticalPosition() const;
+    PositionInContextRoot initialVerticalPosition(Optional<LayoutUnit> previousFloatAbsoluteTop) const;
 };
 

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

@@ -151 +151 @@
 #endif
 
+struct AbsoluteCoordinateValuesForFloatAvoider {
+    Display::Box displayBox;
+    LayoutPoint containingBlockTopLeft;
+    HorizontalEdges containingBlockContentBox;
+};
+static AbsoluteCoordinateValuesForFloatAvoider mapToFormattingContextRoot(const Box& layoutBox, const Container& formattingContextRoot, const LayoutState& layoutState)
+{
+    auto& containingBlock = *layoutBox.containingBlock();
+    auto displayBox = FormattingContext::mapBoxToAncestor(layoutState, layoutBox, formattingContextRoot);
+
+    if (&containingBlock == &formattingContextRoot) {
+        auto containingBlockDisplayBox = layoutState.displayBoxForLayoutBox(containingBlock);
+        return { displayBox, { }, {  containingBlockDisplayBox.contentBoxLeft(), containingBlockDisplayBox.contentBoxRight() } };
+    }
+    auto containingBlockAbsoluteDisplayBox = FormattingContext::mapBoxToAncestor(layoutState, containingBlock, formattingContextRoot);
+    auto containingBlockLeft = containingBlockAbsoluteDisplayBox.left();
+    return { displayBox, containingBlockAbsoluteDisplayBox.topLeft(), { containingBlockLeft + containingBlockAbsoluteDisplayBox.contentBoxLeft(), containingBlockLeft + containingBlockAbsoluteDisplayBox.contentBoxRight() } };
+}
+
 FloatingContext::FloatingContext(const Container& formattingContextRoot, FloatingState& floatingState)
     : m_root(makeWeakPtr(formattingContextRoot))
@@ -180 +199 @@
 
     // Find the top most position where the float box fits.
-    FloatBox floatBox = { layoutBox, m_floatingState, layoutState() };
+    auto absoluteDisplayBoxCoordinates = mapToFormattingContextRoot(layoutBox, downcast<Container>(m_floatingState.root()), layoutState());
+
+    Optional<LayoutUnit> previousFloatAbsoluteTop;
+    if (!isEmpty())
+        previousFloatAbsoluteTop = floatingState().floats().last().rectWithMargin().top();
+    auto floatBox = FloatBox { layoutBox, absoluteDisplayBoxCoordinates.displayBox, absoluteDisplayBoxCoordinates.containingBlockTopLeft, absoluteDisplayBoxCoordinates.containingBlockContentBox, previousFloatAbsoluteTop };
     findPositionForFloatBox(floatBox);
     return floatBox.rectInContainingBlock().topLeft();
@@ -195 +219 @@
         return { };
 
-    FloatAvoider floatAvoider = { layoutBox, m_floatingState, layoutState() };
+    auto absoluteDisplayBoxCoordinates = mapToFormattingContextRoot(layoutBox, downcast<Container>(m_floatingState.root()), layoutState());
+    auto floatAvoider = FloatAvoider { layoutBox, absoluteDisplayBoxCoordinates.displayBox, absoluteDisplayBoxCoordinates.containingBlockTopLeft, absoluteDisplayBoxCoordinates.containingBlockContentBox };
     findPositionForFormattingContextRoot(floatAvoider);
     return { floatAvoider.rectInContainingBlock().topLeft() };

trunk/Source/WebCore/platform/graphics/LayoutPoint.h

@@ -45 +45 @@
 
     static LayoutPoint zero() { return LayoutPoint(); }
+    bool isZero() const { return !m_x && !m_y; }
 
     LayoutUnit x() const { return m_x; }