ChangeLog

2021-11-02  Antti Koivisto  <antti@apple.com>

        [LFC][Integration] Use IFC for preferred width computation in simple cases

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

        Reviewed by NOBODY (OOPS!).

        * layout/formattingContexts/inline/InlineFormattingContext.cpp:

        (WebCore::Layout::InlineFormattingContext::computedIntrinsicWidthConstraints):

        * layout/formattingContexts/inline/InlineFormattingContext.h:

        * layout/integration/LayoutIntegrationLineLayout.cpp:

        (WebCore::LayoutIntegration::LineLayout::computeIntrinsicWidthConstraints):

        * layout/integration/LayoutIntegrationLineLayout.h:

        * rendering/RenderBlockFlow.cpp:

        (WebCore::RenderBlockFlow::computeAndSetLineLayoutPath):

        (WebCore::RenderBlockFlow::layoutInlineChildren):

        (WebCore::RenderBlockFlow::computeInlinePreferredLogicalWidths const):

        (WebCore::RenderBlockFlow::tryComputePreferredWidthsUsingModernPath):

        * rendering/RenderBlockFlow.h:

2021-11-01  Daniel Kolesa  <dkolesa@igalia.com>

        Fix build with GCC 8.4 on Ubuntu 18.04

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

@@void InlineFormattingContext::computeStaticPositionForOutOfFlowContent(const For

IntrinsicWidthConstraints InlineFormattingContext::computedIntrinsicWidthConstraints()

{

    auto& layoutState = this->layoutState();

362 ASSERT(!formattingState().intrinsicWidthConstraints());

362 if (formattingState().intrinsicWidthConstraints())

363 return *formattingState().intrinsicWidthConstraints();

    if (!root().hasInFlowOrFloatingChild()) {

        auto constraints = formattingGeometry().constrainByMinMaxWidth(root(), { });

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

@@public:

    const InlineFormattingGeometry& formattingGeometry() const final { return m_inlineFormattingGeometry; }

    const InlineFormattingQuirks& formattingQuirks() const final { return m_inlineFormattingQuirks; }

61 private:

6261 IntrinsicWidthConstraints computedIntrinsicWidthConstraints() override;

6362

63private:

    void lineLayout(InlineItems&, LineBuilder::InlineItemRange, const ConstraintsForInFlowContent&);

    void computeStaticPositionForOutOfFlowContent(const FormattingState::OutOfFlowBoxList&);

Source/WebCore/layout/integration/LayoutIntegrationLineLayout.cpp

@@void LineLayout::updateStyle(const RenderBoxModelObject& renderer, const RenderS

    m_boxTree.updateStyle(renderer);

}

std::pair<LayoutUnit, LayoutUnit> LineLayout::computeIntrinsicWidthConstraints()

{

    auto inlineFormattingContext = Layout::InlineFormattingContext { rootLayoutBox(), m_inlineFormattingState, nullptr };

    auto constraints = inlineFormattingContext.computedIntrinsicWidthConstraints();

    return { constraints.minimum, constraints.maximum };

}

void LineLayout::layout()

{

    auto& rootLayoutBox = this->rootLayoutBox();

Source/WebCore/layout/integration/LayoutIntegrationLineLayout.h

@@public:

    void updateLineBreakBoxDimensions(const RenderLineBreak&);

    void updateInlineBoxDimensions(const RenderInline&);

    void updateStyle(const RenderBoxModelObject&, const RenderStyle& oldStyle);

    std::pair<LayoutUnit, LayoutUnit> computeIntrinsicWidthConstraints();

    void layout();

    LayoutUnit contentLogicalHeight() const;

Source/WebCore/rendering/RenderBlockFlow.cpp

namespace WebCore {

#define ENABLE_MODERN_PREFERRED_WIDTH_COMPUTATION 1

#define ENABLE_MODERN_PREFERRED_WIDTH_COMPUTATION_FOR_INLINE_BOXES 1

WTF_MAKE_ISO_ALLOCATED_IMPL(RenderBlockFlow);

bool RenderBlock::s_canPropagateFloatIntoSibling = false;

@@void RenderBlockFlow::layoutBlockChildren(bool relayoutChildren, LayoutUnit& max

    handleAfterSideOfBlock(beforeEdge, afterEdge, marginInfo);

}

686 void RenderBlockFlow::~~lay~~o~~utI~~nline~~Children(bool relayoutChildren,~~ Layout~~Unit& repaintLogicalTop, LayoutUnit& repaintLogicalBottom~~)

689void RenderBlockFlow::computeAndSetLineLayoutPath()

687690{

688 auto computeLineLayoutPath = [&] {

    if (lineLayoutPath() != UndeterminedPath)

        return;

    auto compute = [&] {

#if ENABLE(LAYOUT_FORMATTING_CONTEXT)

        if (LayoutIntegration::LineLayout::canUseFor(*this))

            return ModernPath;

@@void RenderBlockFlow::layoutInlineChildren(bool relayoutChildren, LayoutUnit& re

        return LegacyPath;

    };

696 if (lineLayoutPath() == UndeterminedPath)

697 setLineLayoutPath(computeLineLayoutPath());

    setLineLayoutPath(compute());

}

void RenderBlockFlow::layoutInlineChildren(bool relayoutChildren, LayoutUnit& repaintLogicalTop, LayoutUnit& repaintLogicalBottom)

{

    computeAndSetLineLayoutPath();

#if ENABLE(LAYOUT_FORMATTING_CONTEXT)

    if (lineLayoutPath() == ModernPath) {

@@static inline LayoutUnit preferredWidth(LayoutUnit preferredWidth, float result)

void RenderBlockFlow::computeInlinePreferredLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const

{

#if ENABLE(LAYOUT_FORMATTING_CONTEXT)

    if (const_cast<RenderBlockFlow&>(*this).tryComputePreferredWidthsUsingModernPath(minLogicalWidth, maxLogicalWidth))

        return;

#endif

    float inlineMax = 0;

    float inlineMin = 0;

@@void RenderBlockFlow::computeInlinePreferredLogicalWidths(LayoutUnit& minLogical

    maxLogicalWidth = preferredWidth(maxLogicalWidth, inlineMax);

}

#if ENABLE(LAYOUT_FORMATTING_CONTEXT)

bool RenderBlockFlow::tryComputePreferredWidthsUsingModernPath(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth)

{

#if ENABLE_MODERN_PREFERRED_WIDTH_COMPUTATION

    computeAndSetLineLayoutPath();

    // FIXME: Allow inline boxes.

    // FIXME: Pass the replaced and inline block constrainst to IFC.

    auto canUseModernPathForPreferredWidthComputation = [&] {

        if (lineLayoutPath() != ModernPath)

            return false;

        for (auto walker = InlineWalker(*this); !walker.atEnd(); walker.advance()) {

            auto& renderer = *walker.current();

            if (renderer.isText())

                continue;

            if (is<RenderLineBreak>(renderer))

                continue;

#if ENABLE_MODERN_PREFERRED_WIDTH_COMPUTATION_FOR_INLINE_BOXES

            if (is<RenderInline>(renderer))

                continue;

#endif

            return false;

        }

        return true;

    };

    if (!canUseModernPathForPreferredWidthComputation())

        return false;

    if (!modernLineLayout())

        m_lineLayout = makeUnique<LayoutIntegration::LineLayout>(*this);

    std::tie(minLogicalWidth, maxLogicalWidth) = modernLineLayout()->computeIntrinsicWidthConstraints();

    return true;

#else

    UNUSED_PARAM(minLogicalWidth);

    UNUSED_PARAM(maxLogicalWidth);

    return false;

#endif

}

#endif

46024659}

46034660// namespace WebCore

Source/WebCore/rendering/RenderBlockFlow.h

@@public:

    bool hasLines() const;

    void invalidateLineLayoutPath() final;

347 void computeAndSetLineLayoutPath();

    enum LineLayoutPath { UndeterminedPath = 0, ModernPath, LegacyPath, ForcedLegacyPath };

    LineLayoutPath lineLayoutPath() const { return static_cast<LineLayoutPath>(renderBlockFlowLineLayoutPath()); }

    void setLineLayoutPath(LineLayoutPath path) { setRenderBlockFlowLineLayoutPath(path); }

352 void computeLineLayoutPath();

    int lineCount() const;

    void clearTruncation();

@@private:

#if ENABLE(LAYOUT_FORMATTING_CONTEXT)

    bool hasModernLineLayout() const;

    void layoutModernLines(bool relayoutChildren, LayoutUnit& repaintLogicalTop, LayoutUnit& repaintLogicalBottom);

550 bool tryComputePreferredWidthsUsingModernPath(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth);

#endif

    void adjustIntrinsicLogicalWidthsForColumns(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const;

Tools/Scripts/webkitpy/layout_tests/controllers/layout_test_runner.py

@@class LayoutTestRunner(object):

                run_results.add(result, expected=False)

    def _interrupt_if_at_failure_limits(self, run_results):

206 self._options.exit_after_n_failures = None

        # Note: The messages in this method are constructed to match old-run-webkit-tests

        # so that existing buildbot grep rules work.

        def interrupt_if_at_failure_limit(limit, failure_count, run_results, message):