[IFC][Intrinsic width] Decouple min/max computation in InlineFormatti…

…ngContext

https://bugs.webkit.org/show_bug.cgi?id=265527

Reviewed by Antti Koivisto.

This is in preparation for being able to compute min/max sizes on non-text only content where
we would pre-compute the inline level box min/max sized (running regular render tree min/max code)
followed by IFC's min/max computation while switching between these pre-computed geometries (this is exactly how regular integration based layout works).

* Source/WebCore/layout/formattingContexts/inline/InlineFormattingContext.cpp:
(WebCore::Layout::InlineFormattingContext::minimumContentSize):
(WebCore::Layout::InlineFormattingContext::maximumContentSize):
(WebCore::Layout::InlineFormattingContext::computedIntrinsicSizes): Deleted.
* Source/WebCore/layout/formattingContexts/inline/InlineFormattingContext.h:
* Source/WebCore/layout/integration/inline/LayoutIntegrationLineLayout.cpp:
(WebCore::LayoutIntegration::LineLayout::computeIntrinsicWidthConstraints):

Canonical link: https://commits.webkit.org/271369@main

Source/WebCore/layout/formattingContexts/inline/InlineFormattingContext.cpp

@@ -150,45 +150,39 @@ InlineLayoutResult InlineFormattingContext::layout(const ConstraintsForInlineCon
     return lineLayout(lineBuilder, inlineItemList, needsLayoutRange, previousLine(), constraints, lineDamage);
 }
 
-IntrinsicWidthConstraints InlineFormattingContext::computedIntrinsicSizes(const InlineDamage* lineDamage)
+LayoutUnit InlineFormattingContext::minimumContentSize(const InlineDamage* lineDamage)
 {
     auto& inlineContentCache = this->inlineContentCache();
-    if (lineDamage)
-        inlineContentCache.resetMinimumMaximumContentSizes();
-
-    if (inlineContentCache.minimumContentSize() && inlineContentCache.maximumContentSize())
-        return { ceiledLayoutUnit(*inlineContentCache.minimumContentSize()), ceiledLayoutUnit(*inlineContentCache.maximumContentSize()) };
+    if (inlineContentCache.minimumContentSize())
+        return ceiledLayoutUnit(*inlineContentCache.minimumContentSize());
 
     rebuildInlineItemListIfNeeded(lineDamage);
     auto& inlineItemList = inlineContentCache.inlineItems().content();
-    if (!lineDamage && isEmptyInlineContent(inlineItemList)) {
-        inlineContentCache.setMinimumContentSize({ });
-        inlineContentCache.setMaximumContentSize({ });
-        return { };
-    }
-
-    auto mayUseSimplifiedTextOnlyInlineLayout = TextOnlySimpleLineBuilder::isEligibleForSimplifiedTextOnlyInlineLayout(root(), inlineContentCache);
-    auto intrinsicWidthHandler = IntrinsicWidthHandler { *this, inlineItemList, mayUseSimplifiedTextOnlyInlineLayout };
-    if (!inlineContentCache.minimumContentSize())
-        inlineContentCache.setMinimumContentSize(intrinsicWidthHandler.minimumContentSize());
-
-    if (!inlineContentCache.maximumContentSize()) {
-        inlineContentCache.setMaximumContentSize(intrinsicWidthHandler.maximumContentSize());
-        if (intrinsicWidthHandler.maximumIntrinsicWidthResult())
-            inlineContentCache.setMaximumIntrinsicWidthLayoutResult(WTFMove(*intrinsicWidthHandler.maximumIntrinsicWidthResult()));
-    }
-
-    return { ceiledLayoutUnit(*inlineContentCache.minimumContentSize()), ceiledLayoutUnit(*inlineContentCache.maximumContentSize()) };
+    auto minimumContentSize = InlineLayoutUnit { };
+    if (!isEmptyInlineContent(inlineItemList))
+        minimumContentSize = IntrinsicWidthHandler { *this, inlineItemList, TextOnlySimpleLineBuilder::isEligibleForSimplifiedTextOnlyInlineLayout(root(), inlineContentCache) }.minimumContentSize();
+    inlineContentCache.setMinimumContentSize(minimumContentSize);
+    return ceiledLayoutUnit(minimumContentSize);
 }
 
-LayoutUnit InlineFormattingContext::maximumContentSize()
+LayoutUnit InlineFormattingContext::maximumContentSize(const InlineDamage* lineDamage)
 {
     auto& inlineContentCache = this->inlineContentCache();
-    if (auto maximumContentSize = inlineContentCache.maximumContentSize())
-        return ceiledLayoutUnit(*maximumContentSize);
+    if (inlineContentCache.maximumContentSize())
+        return ceiledLayoutUnit(*inlineContentCache.maximumContentSize());
+
+    rebuildInlineItemListIfNeeded(lineDamage);
+    auto& inlineItemList = inlineContentCache.inlineItems().content();
+    auto maximumContentSize = InlineLayoutUnit { };
+    if (!isEmptyInlineContent(inlineItemList)) {
+        auto intrinsicWidthHandler = IntrinsicWidthHandler { *this, inlineItemList, TextOnlySimpleLineBuilder::isEligibleForSimplifiedTextOnlyInlineLayout(root(), inlineContentCache) };
 
-    auto mayUseSimplifiedTextOnlyInlineLayout = TextOnlySimpleLineBuilder::isEligibleForSimplifiedTextOnlyInlineLayout(root(), inlineContentCache);
-    return ceiledLayoutUnit(IntrinsicWidthHandler { *this, inlineContentCache.inlineItems().content(), mayUseSimplifiedTextOnlyInlineLayout }.maximumContentSize());
+        maximumContentSize = intrinsicWidthHandler.maximumContentSize();
+        if (intrinsicWidthHandler.maximumIntrinsicWidthResult())
+            inlineContentCache.setMaximumIntrinsicWidthLayoutResult(WTFMove(*intrinsicWidthHandler.maximumIntrinsicWidthResult()));
+    }
+    inlineContentCache.setMaximumContentSize(maximumContentSize);
+    return ceiledLayoutUnit(maximumContentSize);
 }
 
 static bool mayExitFromPartialLayout(const InlineDamage& lineDamage, size_t lineIndex, const InlineDisplay::Boxes& newContent)

Source/WebCore/layout/formattingContexts/inline/InlineFormattingContext.h

@@ -58,8 +58,8 @@ class InlineFormattingContext {
     InlineFormattingContext(const ElementBox& formattingContextRoot, LayoutState&, BlockLayoutState& parentBlockLayoutState);
 
     InlineLayoutResult layout(const ConstraintsForInlineContent&, const InlineDamage* = nullptr);
-    IntrinsicWidthConstraints computedIntrinsicSizes(const InlineDamage*);
-    LayoutUnit maximumContentSize();
+    LayoutUnit minimumContentSize(const InlineDamage* = nullptr);
+    LayoutUnit maximumContentSize(const InlineDamage* = nullptr);
 
     const ElementBox& root() const { return m_rootBlockContainer; }
     const InlineFormattingUtils& formattingUtils() const { return m_inlineFormattingUtils; }

Source/WebCore/layout/integration/inline/LayoutIntegrationLineLayout.cpp

@@ -217,8 +217,13 @@ void LineLayout::updateOverflow()
 std::pair<LayoutUnit, LayoutUnit> LineLayout::computeIntrinsicWidthConstraints()
 {
     auto parentBlockLayoutState = Layout::BlockLayoutState { m_blockFormattingState.placedFloats() };
-    auto constraints = Layout::InlineFormattingContext { rootLayoutBox(), layoutState(), parentBlockLayoutState }.computedIntrinsicSizes(m_lineDamage.get());
-    return { constraints.minimum, constraints.maximum };
+    auto inlineFormattingContext = Layout::InlineFormattingContext { rootLayoutBox(), layoutState(), parentBlockLayoutState };
+    if (m_lineDamage)
+        m_inlineContentCache.resetMinimumMaximumContentSizes();
+    // FIXME: This is where we need to switch between minimum and maximum box geometries.
+    auto minimumContentSize = inlineFormattingContext.minimumContentSize(m_lineDamage.get());
+    auto maximumContentSize = inlineFormattingContext.maximumContentSize();
+    return { minimumContentSize, maximumContentSize };
 }
 
 static inline std::optional<Layout::BlockLayoutState::LineClamp> lineClamp(const RenderBlockFlow& rootRenderer)