[IFC] Use fast line builder for min/max computation when applicable

https://bugs.webkit.org/show_bug.cgi?id=259936 Reviewed by Antti Koivisto. This patch takes simplified inline builder into use when computing min/max intrinsic sizes. Small related changes: 1. InlineContentBreaker only needs to know whether we are in intrinsic mode or not. 2, No need to reconstruct InlineContentBreaker for each lines 3, No need to construct a new instance of InlineBuilder for min/max computation. * Source/WebCore/layout/formattingContexts/inline/AbstractLineBuilder.h: (WebCore::Layout::AbstractLineBuilder::setIntrinsicWidthMode): (WebCore::Layout::AbstractLineBuilder::intrinsicWidthMode const): (WebCore::Layout::AbstractLineBuilder::isInIntrinsicWidthMode const): * Source/WebCore/layout/formattingContexts/inline/InlineContentBreaker.cpp: (WebCore::Layout::InlineContentBreaker::InlineContentBreaker): Deleted. * Source/WebCore/layout/formattingContexts/inline/InlineContentBreaker.h: (WebCore::Layout::InlineContentBreaker::setHyphenationDisabled): (WebCore::Layout::InlineContentBreaker::setIsInIntrinsicWidthMode): (WebCore::Layout::InlineContentBreaker::isInIntrinsicWidthMode const): * Source/WebCore/layout/formattingContexts/inline/InlineFormattingContext.cpp: (WebCore::Layout::InlineFormattingContext::layoutInFlowAndFloatContent): (WebCore::Layout::InlineFormattingContext::computedIntrinsicWidthConstraints): (WebCore::Layout::InlineFormattingContext::maximumContentSize): (WebCore::Layout::InlineFormattingContext::computedIntrinsicWidthForConstraint const): * Source/WebCore/layout/formattingContexts/inline/InlineFormattingContext.h: * Source/WebCore/layout/formattingContexts/inline/InlineLineBuilder.cpp: (WebCore::Layout::LineBuilder::LineBuilder): (WebCore::Layout::LineBuilder::placeInlineAndFloatContent): (WebCore::Layout::LineBuilder::handleInlineContent): * Source/WebCore/layout/formattingContexts/inline/InlineLineBuilder.h: (WebCore::Layout::LineBuilder::intrinsicWidthMode const): Deleted. (WebCore::Layout::LineBuilder::isInIntrinsicWidthMode const): Deleted. * Source/WebCore/layout/formattingContexts/inline/TextOnlyLineBuilder.cpp: (WebCore::Layout::TextOnlyLineBuilder::TextOnlyLineBuilder): (WebCore::Layout::TextOnlyLineBuilder::placeInlineTextContent): (WebCore::Layout::TextOnlyLineBuilder::placeNonWrappingInlineTextContent): (WebCore::Layout::TextOnlyLineBuilder::handleInlineTextContent): (WebCore::Layout::TextOnlyLineBuilder::isEligibleForSimplifiedTextOnlyInlineLayout): * Source/WebCore/layout/formattingContexts/inline/TextOnlyLineBuilder.h: (WebCore::Layout::TextOnlyLineBuilder::isFirstFormattedLine const): (WebCore::Layout::TextOnlyLineBuilder::TextOnlyLineBuilder): Deleted. (WebCore::Layout::TextOnlyLineBuilder::intrinsicWidthMode const): Deleted. (WebCore::Layout::TextOnlyLineBuilder::isInIntrinsicWidthMode const): Deleted. Canonical link: https://commits.webkit.org/266833@main
WebKit · Aug 11, 2023 · 44bc055 · 44bc055
1 parent f1aca9b
commit 44bc055
Show file tree

Hide file tree

Showing 9 changed files with 66 additions and 59 deletions.
diff --git a/Source/WebCore/layout/formattingContexts/inline/AbstractLineBuilder.h b/Source/WebCore/layout/formattingContexts/inline/AbstractLineBuilder.h
@@ -98,6 +98,16 @@ class AbstractLineBuilder {
 public:
     virtual LineLayoutResult layoutInlineContent(const LineInput&, const std::optional<PreviousLine>&) = 0;
     virtual ~AbstractLineBuilder() { };
+
+    void setIntrinsicWidthMode(IntrinsicWidthMode intrinsicWidthMode) { m_intrinsicWidthMode = intrinsicWidthMode; }
+
+protected:
+    std::optional<IntrinsicWidthMode> intrinsicWidthMode() const { return m_intrinsicWidthMode; }
+    bool isInIntrinsicWidthMode() const { return !!intrinsicWidthMode(); }
+
+private:
+    std::optional<IntrinsicWidthMode> m_intrinsicWidthMode;
+
 };
 
 

diff --git a/Source/WebCore/layout/formattingContexts/inline/InlineContentBreaker.cpp b/Source/WebCore/layout/formattingContexts/inline/InlineContentBreaker.cpp
@@ -108,11 +108,6 @@ static inline std::optional<size_t> firstTextRunIndex(const InlineContentBreaker
     return { };
 }
 
-InlineContentBreaker::InlineContentBreaker(std::optional<IntrinsicWidthMode> intrinsicWidthMode)
-    : m_intrinsicWidthMode(intrinsicWidthMode)
-{
-}
-
 InlineContentBreaker::Result InlineContentBreaker::processInlineContent(const ContinuousContent& candidateContent, const LineStatus& lineStatus)
 {
     ASSERT(!std::isnan(lineStatus.availableWidth));

diff --git a/Source/WebCore/layout/formattingContexts/inline/InlineContentBreaker.h b/Source/WebCore/layout/formattingContexts/inline/InlineContentBreaker.h
@@ -40,8 +40,6 @@ struct CandidateTextRunForBreaking;
 
 class InlineContentBreaker {
 public:
-    InlineContentBreaker(std::optional<IntrinsicWidthMode>);
-
     struct PartialRun {
         size_t length { 0 };
         InlineLayoutUnit logicalWidth { 0 };
@@ -130,8 +128,8 @@ class InlineContentBreaker {
         bool hasWrapOpportunityAtPreviousPosition { false };
     };
     Result processInlineContent(const ContinuousContent&, const LineStatus&);
-    void setHyphenationDisabled() { n_hyphenationIsDisabled = true; }
-
+    void setHyphenationDisabled(bool hyphenationIsDisabled) { n_hyphenationIsDisabled = hyphenationIsDisabled; }
+    void setIsInIntrinsicWidthMode(bool isInIntrinsicWidthMode) { m_isInIntrinsicWidthMode = isInIntrinsicWidthMode; }
     static bool isWrappingAllowed(const ContinuousContent::Run&);
 
 private:
@@ -165,9 +163,10 @@ class InlineContentBreaker {
         AtHyphenationOpportunities     = 1 << 2
     };
     OptionSet<WordBreakRule> wordBreakBehavior(const RenderStyle&, bool hasWrapOpportunityAtPreviousPosition) const;
-    bool isInIntrinsicWidthMode() const { return !!m_intrinsicWidthMode; }
+    bool isInIntrinsicWidthMode() const { return m_isInIntrinsicWidthMode; }
 
-    std::optional<IntrinsicWidthMode> m_intrinsicWidthMode;
+private:
+    bool m_isInIntrinsicWidthMode { false };
     bool n_hyphenationIsDisabled { false };
 };
 

diff --git a/Source/WebCore/layout/formattingContexts/inline/InlineFormattingContext.cpp b/Source/WebCore/layout/formattingContexts/inline/InlineFormattingContext.cpp
@@ -94,7 +94,7 @@ InlineLayoutResult InlineFormattingContext::layoutInFlowAndFloatContent(const Co
         return PreviousLine { lastLineIndex, { }, { }, { }, { } };
     };
 
-    if (TextOnlyLineBuilder::isEligibleForSimplifiedTextOnlyInlineLayout(root(), floatingState, formattingState())) {
+    if (TextOnlyLineBuilder::isEligibleForSimplifiedTextOnlyInlineLayout(root(), formattingState(), &floatingState)) {
         auto simplifiedLineBuilder = TextOnlyLineBuilder { *this, constraints.horizontal(), inlineItems };
         return lineLayout(simplifiedLineBuilder, inlineItems, needsLayoutRange, previousLine(), constraints, inlineLayoutState);
     }
@@ -114,20 +114,30 @@ IntrinsicWidthConstraints InlineFormattingContext::computedIntrinsicWidthConstra
     if (m_lineDamage)
         inlineFormattingState.resetIntrinsicWidthConstraints();
 
-    if (auto intrinsicWidthConstraints = inlineFormattingState.intrinsicWidthConstraints())
-        return *intrinsicWidthConstraints;
+    if (auto intrinsicSizes = inlineFormattingState.intrinsicWidthConstraints())
+        return *intrinsicSizes;
 
     auto needsLayoutStartPosition = !m_lineDamage || !m_lineDamage->start() ? InlineItemPosition() : m_lineDamage->start()->inlineItemPosition;
     auto needsInlineItemsUpdate = inlineFormattingState.inlineItems().isEmpty() || m_lineDamage;
     if (needsInlineItemsUpdate)
         InlineItemsBuilder { root(), inlineFormattingState }.build(needsLayoutStartPosition);
 
-    auto constraints = IntrinsicWidthConstraints {
-        ceiledLayoutUnit(computedIntrinsicWidthForConstraint(IntrinsicWidthMode::Minimum)),
-        ceiledLayoutUnit(computedIntrinsicWidthForConstraint(IntrinsicWidthMode::Maximum))
+    auto computedIntrinsicValue = [&](auto intrinsicWidthMode, auto& inlineBuilder) {
+        inlineBuilder.setIntrinsicWidthMode(intrinsicWidthMode);
+        return ceiledLayoutUnit(computedIntrinsicWidthForConstraint(intrinsicWidthMode, inlineBuilder));
     };
-    formattingState().setIntrinsicWidthConstraints(constraints);
-    return constraints;
+
+    if (TextOnlyLineBuilder::isEligibleForSimplifiedTextOnlyInlineLayout(root(), inlineFormattingState)) {
+        auto simplifiedLineBuilder = TextOnlyLineBuilder { *this, { }, inlineFormattingState.inlineItems() };
+        return { computedIntrinsicValue(IntrinsicWidthMode::Minimum, simplifiedLineBuilder), computedIntrinsicValue(IntrinsicWidthMode::Maximum, simplifiedLineBuilder) };
+    }
+
+    auto floatingState = FloatingState { root() };
+    auto parentBlockLayoutState = BlockLayoutState { floatingState, { } };
+    auto inlineLayoutState = InlineLayoutState { parentBlockLayoutState, { } };
+    auto lineBuilder = LineBuilder { *this, inlineLayoutState, floatingState, { }, inlineFormattingState.inlineItems() };
+
+    return { computedIntrinsicValue(IntrinsicWidthMode::Minimum, lineBuilder), computedIntrinsicValue(IntrinsicWidthMode::Maximum, lineBuilder) };
 }
 
 LayoutUnit InlineFormattingContext::maximumContentSize()
@@ -139,7 +149,13 @@ LayoutUnit InlineFormattingContext::maximumContentSize()
     if (inlineFormattingState.inlineItems().isEmpty())
         InlineItemsBuilder { root(), inlineFormattingState }.build({ });
 
-    return ceiledLayoutUnit(computedIntrinsicWidthForConstraint(IntrinsicWidthMode::Maximum));
+    auto floatingState = FloatingState { root() };
+    auto parentBlockLayoutState = BlockLayoutState { floatingState, { } };
+    auto inlineLayoutState = InlineLayoutState { parentBlockLayoutState, { } };
+    auto lineBuilder = LineBuilder { *this, inlineLayoutState, floatingState, { }, inlineFormattingState.inlineItems() };
+    lineBuilder.setIntrinsicWidthMode(IntrinsicWidthMode::Maximum);
+
+    return ceiledLayoutUnit(computedIntrinsicWidthForConstraint(IntrinsicWidthMode::Maximum, lineBuilder));
 }
 
 static InlineItemPosition leadingInlineItemPositionForNextLine(InlineItemPosition lineContentEnd, std::optional<InlineItemPosition> previousLineTrailingInlineItemPosition, InlineItemPosition layoutRangeEnd)
@@ -266,16 +282,12 @@ void InlineFormattingContext::computeStaticPositionForOutOfFlowContent(const For
     }
 }
 
-InlineLayoutUnit InlineFormattingContext::computedIntrinsicWidthForConstraint(IntrinsicWidthMode intrinsicWidthMode) const
+InlineLayoutUnit InlineFormattingContext::computedIntrinsicWidthForConstraint(IntrinsicWidthMode intrinsicWidthMode, AbstractLineBuilder& lineBuilder) const
 {
-    auto floatingState = FloatingState { root() };
-    auto parentBlockLayoutState = BlockLayoutState { floatingState, { } };
-    auto inlineLayoutState = InlineLayoutState { parentBlockLayoutState, { } };
     auto horizontalConstraints = HorizontalConstraints { };
     if (intrinsicWidthMode == IntrinsicWidthMode::Maximum)
         horizontalConstraints.logicalWidth = maxInlineLayoutUnit();
     auto& inlineItems = formattingState().inlineItems();
-    auto lineBuilder = LineBuilder { *this, inlineLayoutState, floatingState, horizontalConstraints, inlineItems, intrinsicWidthMode };
     auto layoutRange = InlineItemRange { 0 , inlineItems.size() };
     auto maximumContentWidth = InlineLayoutUnit { };
     auto previousLineEnd = std::optional<InlineItemPosition> { };

diff --git a/Source/WebCore/layout/formattingContexts/inline/InlineFormattingContext.h b/Source/WebCore/layout/formattingContexts/inline/InlineFormattingContext.h
@@ -73,7 +73,7 @@ class InlineFormattingContext final : public FormattingContext {
     void layoutFloatContentOnly(const ConstraintsForInlineContent&, FloatingState&);
     void computeStaticPositionForOutOfFlowContent(const FormattingState::OutOfFlowBoxList&, const ConstraintsForInFlowContent&, const InlineDisplay::Content&, const FloatingState&);
 
-    InlineLayoutUnit computedIntrinsicWidthForConstraint(IntrinsicWidthMode) const;
+    InlineLayoutUnit computedIntrinsicWidthForConstraint(IntrinsicWidthMode, AbstractLineBuilder&) const;
 
     void collectContentIfNeeded();
     InlineRect createDisplayContentForLine(size_t lineIndex, const LineLayoutResult&, const ConstraintsForInlineContent&, const InlineLayoutState&, InlineDisplay::Content&);

diff --git a/Source/WebCore/layout/formattingContexts/inline/InlineLineBuilder.cpp b/Source/WebCore/layout/formattingContexts/inline/InlineLineBuilder.cpp
@@ -303,9 +303,8 @@ InlineLayoutUnit LineBuilder::inlineItemWidth(const InlineItem& inlineItem, Inli
     return boxGeometry.marginBoxWidth();
 }
 
-LineBuilder::LineBuilder(const InlineFormattingContext& inlineFormattingContext, const InlineLayoutState& inlineLayoutState, FloatingState& floatingState, HorizontalConstraints rootHorizontalConstraints, const InlineItems& inlineItems, std::optional<IntrinsicWidthMode> intrinsicWidthMode)
-    : m_intrinsicWidthMode(intrinsicWidthMode)
-    , m_inlineFormattingContext(inlineFormattingContext)
+LineBuilder::LineBuilder(const InlineFormattingContext& inlineFormattingContext, const InlineLayoutState& inlineLayoutState, FloatingState& floatingState, HorizontalConstraints rootHorizontalConstraints, const InlineItems& inlineItems)
+    : m_inlineFormattingContext(inlineFormattingContext)
     , m_inlineLayoutState(inlineLayoutState)
     , m_floatingState(floatingState)
     , m_rootHorizontalConstraints(rootHorizontalConstraints)
@@ -449,7 +448,6 @@ LineContent LineBuilder::placeInlineAndFloatContent(const InlineItemRange& needs
 
     auto layoutInlineAndFloatContent = [&] {
         auto lineCandidate = LineCandidate { };
-        auto inlineContentBreaker = InlineContentBreaker { intrinsicWidthMode() };
 
         auto currentItemIndex = needsLayoutRange.startIndex();
         while (currentItemIndex < needsLayoutRange.endIndex()) {
@@ -469,7 +467,7 @@ LineContent LineBuilder::placeInlineAndFloatContent(const InlineItemRange& needs
                 }
                 ++placedInlineItemCount;
             } else {
-                auto result = handleInlineContent(inlineContentBreaker, needsLayoutRange, lineCandidate);
+                auto result = handleInlineContent(needsLayoutRange, lineCandidate);
                 auto isEndOfLine = result.isEndOfLine == InlineContentBreaker::IsEndOfLine::Yes;
                 if (!result.committedCount.isRevert) {
                     placedInlineItemCount += result.committedCount.value;
@@ -1137,7 +1135,7 @@ bool LineBuilder::tryPlacingFloatBox(const Box& floatBox, MayOverConstrainLine m
     return true;
 }
 
-LineBuilder::Result LineBuilder::handleInlineContent(InlineContentBreaker& inlineContentBreaker, const InlineItemRange& layoutRange, const LineCandidate& lineCandidate)
+LineBuilder::Result LineBuilder::handleInlineContent(const InlineItemRange& layoutRange, const LineCandidate& lineCandidate)
 {
     auto& inlineContent = lineCandidate.inlineContent;
     auto& continuousInlineContent = inlineContent.continuousContent();
@@ -1146,8 +1144,8 @@ LineBuilder::Result LineBuilder::handleInlineContent(InlineContentBreaker& inlin
         ASSERT(inlineContent.trailingLineBreak() || inlineContent.trailingWordBreakOpportunity());
         return { inlineContent.trailingLineBreak() ? InlineContentBreaker::IsEndOfLine::Yes : InlineContentBreaker::IsEndOfLine::No };
     }
-    if (shouldDisableHyphenation(root().style(), m_successiveHyphenatedLineCount))
-        inlineContentBreaker.setHyphenationDisabled();
+    m_inlineContentBreaker.setHyphenationDisabled(shouldDisableHyphenation(root().style(), m_successiveHyphenatedLineCount));
+    m_inlineContentBreaker.setIsInIntrinsicWidthMode(isInIntrinsicWidthMode());
 
     // While the floats are not considered to be on the line, they make the line contentful for line breaking.
     auto [lineRectAdjutedWithCandidateContent, candidateContentIsConstrainedByFloat] = adjustedLineRectWithCandidateInlineContent(lineCandidate);
@@ -1253,7 +1251,7 @@ LineBuilder::Result LineBuilder::handleInlineContent(InlineContentBreaker& inlin
         return { InlineContentBreaker::IsEndOfLine::No };
     };
 
-    auto lineBreakingResult = inlineContentBreaker.processInlineContent(continuousInlineContent, lineStatus);
+    auto lineBreakingResult = m_inlineContentBreaker.processInlineContent(continuousInlineContent, lineStatus);
     auto lineGainsNewContent = lineBreakingResult.action == InlineContentBreaker::Result::Action::Keep || lineBreakingResult.action == InlineContentBreaker::Result::Action::Break; 
     if (lineGainsNewContent) {
         // Sometimes in order to put this content on the line, we have to avoid additional float boxes (when the new content is taller than any previous content and we have vertically stacked floats on this line)

diff --git a/Source/WebCore/layout/formattingContexts/inline/InlineLineBuilder.h b/Source/WebCore/layout/formattingContexts/inline/InlineLineBuilder.h
@@ -42,7 +42,7 @@ struct LineCandidate;
 
 class LineBuilder : public AbstractLineBuilder {
 public:
-    LineBuilder(const InlineFormattingContext&, const InlineLayoutState&, FloatingState&, HorizontalConstraints rootHorizontalConstraints, const InlineItems&, std::optional<IntrinsicWidthMode> = std::nullopt);
+    LineBuilder(const InlineFormattingContext&, const InlineLayoutState&, FloatingState&, HorizontalConstraints rootHorizontalConstraints, const InlineItems&);
     virtual ~LineBuilder() { };
     LineLayoutResult layoutInlineContent(const LineInput&, const std::optional<PreviousLine>&) final;
 
@@ -72,7 +72,7 @@ class LineBuilder : public AbstractLineBuilder {
     };
     enum MayOverConstrainLine : bool { No, Yes };
     bool tryPlacingFloatBox(const Box&, MayOverConstrainLine);
-    Result handleInlineContent(InlineContentBreaker&, const InlineItemRange& needsLayoutRange, const LineCandidate&);
+    Result handleInlineContent(const InlineItemRange& needsLayoutRange, const LineCandidate&);
     std::tuple<InlineRect, bool> adjustedLineRectWithCandidateInlineContent(const LineCandidate&) const;
     size_t rebuildLineWithInlineContent(const InlineItemRange& needsLayoutRange, const InlineItem& lastInlineItemToAdd);
     size_t rebuildLineForTrailingSoftHyphen(const InlineItemRange& layoutRange);
@@ -88,9 +88,6 @@ class LineBuilder : public AbstractLineBuilder {
     InlineLayoutUnit inlineItemWidth(const InlineItem&, InlineLayoutUnit contentLogicalLeft) const;
     bool isLastLineWithInlineContent(const InlineItemRange& lineRange, size_t lastInlineItemIndex, bool hasPartialTrailingContent) const;
 
-    std::optional<IntrinsicWidthMode> intrinsicWidthMode() const { return m_intrinsicWidthMode; }
-    bool isInIntrinsicWidthMode() const { return !!intrinsicWidthMode(); }
-
     TextDirection inlineBaseDirectionForLineContent() const;
     InlineLayoutUnit horizontalAlignmentOffset(bool isLastLine) const;
 
@@ -108,13 +105,13 @@ class LineBuilder : public AbstractLineBuilder {
 
 private:
     std::optional<PreviousLine> m_previousLine { };
-    std::optional<IntrinsicWidthMode> m_intrinsicWidthMode;
     const InlineFormattingContext& m_inlineFormattingContext;
     const InlineLayoutState& m_inlineLayoutState;
     FloatingState& m_floatingState;
     std::optional<HorizontalConstraints> m_rootHorizontalConstraints;
 
     Line m_line;
+    InlineContentBreaker m_inlineContentBreaker;
     InlineRect m_lineInitialLogicalRect;
     InlineRect m_lineLogicalRect;
     InlineLayoutUnit m_lineMarginStart { 0.f };

diff --git a/Source/WebCore/layout/formattingContexts/inline/TextOnlyLineBuilder.cpp b/Source/WebCore/layout/formattingContexts/inline/TextOnlyLineBuilder.cpp
@@ -87,9 +87,8 @@ static inline bool consumeTrailingLineBreakIfApplicable(const TextOnlyLineBreakR
     return true;
 }
 
-TextOnlyLineBuilder::TextOnlyLineBuilder(const InlineFormattingContext& inlineFormattingContext, HorizontalConstraints rootHorizontalConstraints, const InlineItems& inlineItems, std::optional<IntrinsicWidthMode> intrinsicWidthMode)
-    : m_intrinsicWidthMode(intrinsicWidthMode)
-    , m_inlineFormattingContext(inlineFormattingContext)
+TextOnlyLineBuilder::TextOnlyLineBuilder(const InlineFormattingContext& inlineFormattingContext, HorizontalConstraints rootHorizontalConstraints, const InlineItems& inlineItems)
+    : m_inlineFormattingContext(inlineFormattingContext)
     , m_rootHorizontalConstraints(rootHorizontalConstraints)
     , m_line(inlineFormattingContext)
     , m_inlineItems(inlineItems)
@@ -141,8 +140,6 @@ void TextOnlyLineBuilder::initialize(const InlineItemRange& layoutRange, const I
 InlineItemPosition TextOnlyLineBuilder::placeInlineTextContent(const InlineItemRange& layoutRange)
 {
     auto candidateContent = InlineContentBreaker::ContinuousContent { };
-    auto inlineContentBreaker = InlineContentBreaker { intrinsicWidthMode() };
-
     auto isFirstFormattedLine = this->isFirstFormattedLine();
     auto isEndOfLine = false;
 
@@ -151,7 +148,7 @@ InlineItemPosition TextOnlyLineBuilder::placeInlineTextContent(const InlineItemR
     auto placeSingleInlineTextItem = [&] (auto& inlineTextItem) {
         candidateContent.reset();
         appendInlineTextItem(inlineTextItem, isFirstFormattedLine, m_line, candidateContent);
-        result = handleInlineTextContent(inlineContentBreaker, candidateContent, layoutRange);
+        result = handleInlineTextContent(candidateContent, layoutRange);
         nextItemIndex = !result.isRevert ? nextItemIndex + result.committedCount : result.committedCount;
         isEndOfLine = result.isEndOfLine == InlineContentBreaker::IsEndOfLine::Yes || nextItemIndex >= layoutRange.endIndex();
     };
@@ -189,8 +186,6 @@ InlineItemPosition TextOnlyLineBuilder::placeNonWrappingInlineTextContent(const
     ASSERT(!TextUtil::isWrappingAllowed(root().style()));
 
     auto candidateContent = InlineContentBreaker::ContinuousContent { };
-    auto inlineContentBreaker = InlineContentBreaker { intrinsicWidthMode() };
-
     auto isFirstFormattedLine = this->isFirstFormattedLine();
     auto isEndOfLine = false;
     auto trailingLineBreakIndex = std::optional<size_t> { };
@@ -217,7 +212,7 @@ InlineItemPosition TextOnlyLineBuilder::placeNonWrappingInlineTextContent(const
         return { *trailingLineBreakIndex + 1, { } };
     }
 
-    auto result = handleInlineTextContent(inlineContentBreaker, candidateContent, layoutRange);
+    auto result = handleInlineTextContent(candidateContent, layoutRange);
     nextItemIndex = layoutRange.startIndex() + result.committedCount;
     if (consumeTrailingLineBreakIfApplicable(result, nextItemIndex, layoutRange.endIndex(), m_line, m_inlineItems))
         ++nextItemIndex;
@@ -228,11 +223,12 @@ InlineItemPosition TextOnlyLineBuilder::placeNonWrappingInlineTextContent(const
     return placedContentEnd;
 }
 
-TextOnlyLineBreakResult TextOnlyLineBuilder::handleInlineTextContent(InlineContentBreaker& inlineContentBreaker, const InlineContentBreaker::ContinuousContent& candidateContent, const InlineItemRange& layoutRange)
+TextOnlyLineBreakResult TextOnlyLineBuilder::handleInlineTextContent(const InlineContentBreaker::ContinuousContent& candidateContent, const InlineItemRange& layoutRange)
 {
     auto availableWidth = (m_lineLogicalRect.width() + LayoutUnit::epsilon()) - m_line.contentLogicalRight();
     auto lineStatus = InlineContentBreaker::LineStatus { m_line.contentLogicalRight(), availableWidth, m_line.trimmableTrailingWidth(), m_line.trailingSoftHyphenWidth(), m_line.isTrailingRunFullyTrimmable(), m_line.hasContentOrListMarker(), !m_wrapOpportunityList.isEmpty() };
-    auto lineBreakingResult = inlineContentBreaker.processInlineContent(candidateContent, lineStatus);
+    m_inlineContentBreaker.setIsInIntrinsicWidthMode(isInIntrinsicWidthMode());
+    auto lineBreakingResult = m_inlineContentBreaker.processInlineContent(candidateContent, lineStatus);
 
     ASSERT(!candidateContent.runs().isEmpty());
 
@@ -347,9 +343,9 @@ const ElementBox& TextOnlyLineBuilder::root() const
     return formattingContext().root();
 }
 
-bool TextOnlyLineBuilder::isEligibleForSimplifiedTextOnlyInlineLayout(const ElementBox& rootBox, const FloatingState& floatingState, const InlineFormattingState& inlineFormattingState)
+bool TextOnlyLineBuilder::isEligibleForSimplifiedTextOnlyInlineLayout(const ElementBox& rootBox, const InlineFormattingState& inlineFormattingState, const FloatingState* floatingState)
 {
-    if (!floatingState.isEmpty())
+    if (floatingState && !floatingState->isEmpty())
         return false;
     if (!inlineFormattingState.isNonBidiTextAndForcedLineBreakOnlyContent())
         return false;