From 1bf1084f2b10c3b47fd1a588d85d21ed0eb41d0c Mon Sep 17 00:00:00 2001
From: Lorry Tar Creator <lorry-tar-importer@lorry>
Date: Tue, 27 Jun 2017 06:07:23 +0000
Subject: webkitgtk-2.16.5

---
 Source/WebCore/rendering/SimpleLineLayout.cpp | 1093 +++++++++++++++++--------
 1 file changed, 766 insertions(+), 327 deletions(-)

(limited to 'Source/WebCore/rendering/SimpleLineLayout.cpp')

diff --git a/Source/WebCore/rendering/SimpleLineLayout.cpp b/Source/WebCore/rendering/SimpleLineLayout.cpp
index b0f0b31af..454e71e5c 100644
--- a/Source/WebCore/rendering/SimpleLineLayout.cpp
+++ b/Source/WebCore/rendering/SimpleLineLayout.cpp
@@ -33,440 +33,879 @@
 #include "HitTestLocation.h"
 #include "HitTestRequest.h"
 #include "HitTestResult.h"
+#include "Hyphenation.h"
 #include "InlineTextBox.h"
 #include "LineWidth.h"
+#include "Logging.h"
 #include "PaintInfo.h"
 #include "RenderBlockFlow.h"
+#include "RenderChildIterator.h"
+#include "RenderLineBreak.h"
 #include "RenderStyle.h"
 #include "RenderText.h"
 #include "RenderTextControl.h"
-#include "RenderView.h"
 #include "Settings.h"
+#include "SimpleLineLayoutFlowContents.h"
 #include "SimpleLineLayoutFunctions.h"
+#include "SimpleLineLayoutTextFragmentIterator.h"
 #include "Text.h"
 #include "TextPaintStyle.h"
-#include "break_lines.h"
-#include <wtf/unicode/Unicode.h>
 
 namespace WebCore {
 namespace SimpleLineLayout {
 
+#ifndef NDEBUG
+#define SET_REASON_AND_RETURN_IF_NEEDED(reason, reasons, includeReasons) { \
+        reasons |= reason; \
+        if (includeReasons == IncludeReasons::First) \
+            return reasons; \
+    }
+#else
+#define SET_REASON_AND_RETURN_IF_NEEDED(reason, reasons, includeReasons) { \
+        ASSERT_UNUSED(includeReasons, includeReasons == IncludeReasons::First); \
+        reasons |= reason; \
+        return reasons; \
+    }
+#endif
+
+
+template <typename CharacterType> AvoidanceReasonFlags canUseForCharacter(CharacterType, bool textIsJustified, IncludeReasons);
+
+template<> AvoidanceReasonFlags canUseForCharacter(UChar character, bool textIsJustified, IncludeReasons includeReasons)
+{
+    AvoidanceReasonFlags reasons = { };
+    if (textIsJustified) {
+        // Include characters up to Latin Extended-B and some punctuation range when text is justified.
+        bool isLatinIncludingExtendedB = character <= 0x01FF;
+        bool isPunctuationRange = character >= 0x2010 && character <= 0x2027;
+        if (!(isLatinIncludingExtendedB || isPunctuationRange))
+            SET_REASON_AND_RETURN_IF_NEEDED(FlowHasJustifiedNonLatinText, reasons, includeReasons);
+    }
+
+    if (U16_IS_SURROGATE(character))
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowTextHasSurrogatePair, reasons, includeReasons);
+    
+    UCharDirection direction = u_charDirection(character);
+    if (direction == U_RIGHT_TO_LEFT || direction == U_RIGHT_TO_LEFT_ARABIC
+        || direction == U_RIGHT_TO_LEFT_EMBEDDING || direction == U_RIGHT_TO_LEFT_OVERRIDE
+        || direction == U_LEFT_TO_RIGHT_EMBEDDING || direction == U_LEFT_TO_RIGHT_OVERRIDE
+        || direction == U_POP_DIRECTIONAL_FORMAT || direction == U_BOUNDARY_NEUTRAL)
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowTextHasDirectionCharacter, reasons, includeReasons);
+
+    return reasons;
+}
+
+template<> AvoidanceReasonFlags canUseForCharacter(LChar, bool, IncludeReasons)
+{
+    return { };
+}
+
 template <typename CharacterType>
-static bool canUseForText(const CharacterType* text, unsigned length, const SimpleFontData& fontData)
+static AvoidanceReasonFlags canUseForText(const CharacterType* text, unsigned length, const FontCascade& fontCascade, std::optional<float> lineHeightConstraint,
+    bool textIsJustified, IncludeReasons includeReasons)
 {
-    // FIXME: <textarea maxlength=0> generates empty text node.
-    if (!length)
-        return false;
+    AvoidanceReasonFlags reasons = { };
+    auto& primaryFont = fontCascade.primaryFont();
+    auto& fontMetrics = primaryFont.fontMetrics();
+    auto availableSpaceForGlyphAscent = fontMetrics.ascent();
+    auto availableSpaceForGlyphDescent = fontMetrics.descent();
+    if (lineHeightConstraint) {
+        auto lineHeightPadding = *lineHeightConstraint - fontMetrics.height();
+        availableSpaceForGlyphAscent += lineHeightPadding / 2;
+        availableSpaceForGlyphDescent += lineHeightPadding / 2;
+    }
+
     for (unsigned i = 0; i < length; ++i) {
-        UChar character = text[i];
-        if (character == ' ')
+        auto character = text[i];
+        if (FontCascade::treatAsSpace(character))
             continue;
 
-        // These would be easy to support.
-        if (character == noBreakSpace)
-            return false;
         if (character == softHyphen)
-            return false;
+            SET_REASON_AND_RETURN_IF_NEEDED(FlowTextHasSoftHyphen, reasons, includeReasons);
 
-        UCharDirection direction = u_charDirection(character);
-        if (direction == U_RIGHT_TO_LEFT || direction == U_RIGHT_TO_LEFT_ARABIC
-            || direction == U_RIGHT_TO_LEFT_EMBEDDING || direction == U_RIGHT_TO_LEFT_OVERRIDE
-            || direction == U_LEFT_TO_RIGHT_EMBEDDING || direction == U_LEFT_TO_RIGHT_OVERRIDE
-            || direction == U_POP_DIRECTIONAL_FORMAT || direction == U_BOUNDARY_NEUTRAL)
-            return false;
+        auto characterReasons = canUseForCharacter(character, textIsJustified, includeReasons);
+        if (characterReasons != NoReason)
+            SET_REASON_AND_RETURN_IF_NEEDED(characterReasons, reasons, includeReasons);
 
-        if (!fontData.glyphForCharacter(character))
-            return false;
+        auto glyphData = fontCascade.glyphDataForCharacter(character, false);
+        if (!glyphData.isValid() || glyphData.font != &primaryFont)
+            SET_REASON_AND_RETURN_IF_NEEDED(FlowPrimaryFontIsInsufficient, reasons, includeReasons);
+
+        if (lineHeightConstraint) {
+            auto bounds = primaryFont.boundsForGlyph(glyphData.glyph);
+            if (ceilf(-bounds.y()) > availableSpaceForGlyphAscent || ceilf(bounds.maxY()) > availableSpaceForGlyphDescent)
+                SET_REASON_AND_RETURN_IF_NEEDED(FlowFontHasOverflowGlyph, reasons, includeReasons);
+        }
     }
-    return true;
+    return reasons;
 }
 
-static bool canUseForText(const RenderText& textRenderer, const SimpleFontData& fontData)
+static AvoidanceReasonFlags canUseForText(StringView text, const FontCascade& fontCascade, std::optional<float> lineHeightConstraint, bool textIsJustified, IncludeReasons includeReasons)
 {
-    if (textRenderer.is8Bit())
-        return canUseForText(textRenderer.characters8(), textRenderer.textLength(), fontData);
-    return canUseForText(textRenderer.characters16(), textRenderer.textLength(), fontData);
+    if (text.is8Bit())
+        return canUseForText(text.characters8(), text.length(), fontCascade, lineHeightConstraint, textIsJustified, includeReasons);
+    return canUseForText(text.characters16(), text.length(), fontCascade, lineHeightConstraint, textIsJustified, includeReasons);
 }
 
-bool canUseFor(const RenderBlockFlow& flow)
+static AvoidanceReasonFlags canUseForFontAndText(const RenderBlockFlow& flow, IncludeReasons includeReasons)
 {
-#if !PLATFORM(MAC) && !PLATFORM(GTK) && !PLATFORM(EFL)
-    // FIXME: Non-mac platforms are hitting ASSERT(run.charactersLength() >= run.length())
-    // https://bugs.webkit.org/show_bug.cgi?id=123338
-    return false;
-#else
-    if (!flow.frame().settings().simpleLineLayoutEnabled())
-        return false;
-    if (!flow.firstChild())
-        return false;
-    // This currently covers <blockflow>#text</blockflow> case.
-    // The <blockflow><inline>#text</inline></blockflow> case is also popular and should be relatively easy to cover.
-    if (flow.firstChild() != flow.lastChild())
-        return false;
-    if (!flow.firstChild()->isText())
-        return false;
-    if (!flow.isHorizontalWritingMode())
-        return false;
-    if (flow.flowThreadState() != RenderObject::NotInsideFlowThread)
-        return false;
-    if (flow.hasOutline())
-        return false;
-    if (flow.isRubyText() || flow.isRubyBase())
-        return false;
-    if (flow.parent()->isDeprecatedFlexibleBox())
-        return false;
-    // FIXME: Implementation of wrap=hard looks into lineboxes.
-    if (flow.parent()->isTextArea() && flow.parent()->element()->fastHasAttribute(HTMLNames::wrapAttr))
-        return false;
-    // FIXME: Placeholders do something strange.
-    if (flow.parent()->isTextControl() && toRenderTextControl(*flow.parent()).textFormControlElement().placeholderElement())
-        return false;
-    // These tests only works during layout. Outside layout this function may give false positives.
-    if (flow.view().layoutState()) {
-#if ENABLE(CSS_SHAPES)
-        if (flow.view().layoutState()->shapeInsideInfo())
-            return false;
-#endif
-        if (flow.view().layoutState()->m_columnInfo)
-            return false;
+    AvoidanceReasonFlags reasons = { };
+    // We assume that all lines have metrics based purely on the primary font.
+    const auto& style = flow.style();
+    auto& fontCascade = style.fontCascade();
+    if (fontCascade.primaryFont().isLoading())
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowIsMissingPrimaryFont, reasons, includeReasons);
+    std::optional<float> lineHeightConstraint;
+    if (style.lineBoxContain() & LineBoxContainGlyphs)
+        lineHeightConstraint = lineHeightFromFlow(flow).toFloat();
+    bool flowIsJustified = style.textAlign() == JUSTIFY;
+    for (const auto& textRenderer : childrenOfType<RenderText>(flow)) {
+        // FIXME: Do not return until after checking all children.
+        if (!textRenderer.textLength())
+            SET_REASON_AND_RETURN_IF_NEEDED(FlowTextIsEmpty, reasons, includeReasons);
+        if (textRenderer.isCombineText())
+            SET_REASON_AND_RETURN_IF_NEEDED(FlowTextIsCombineText, reasons, includeReasons);
+        if (textRenderer.isCounter())
+            SET_REASON_AND_RETURN_IF_NEEDED(FlowTextIsRenderCounter, reasons, includeReasons);
+        if (textRenderer.isQuote())
+            SET_REASON_AND_RETURN_IF_NEEDED(FlowTextIsRenderQuote, reasons, includeReasons);
+        if (textRenderer.isTextFragment())
+            SET_REASON_AND_RETURN_IF_NEEDED(FlowTextIsTextFragment, reasons, includeReasons);
+        if (textRenderer.isSVGInlineText())
+            SET_REASON_AND_RETURN_IF_NEEDED(FlowTextIsSVGInlineText, reasons, includeReasons);
+        if (!textRenderer.canUseSimpleFontCodePath()) {
+            // No need to check the code path at this point. We already know it can't be simple.
+            SET_REASON_AND_RETURN_IF_NEEDED(FlowHasComplexFontCodePath, reasons, includeReasons);
+        } else {
+            TextRun run(textRenderer.text());
+            run.setCharacterScanForCodePath(false);
+            if (style.fontCascade().codePath(run) != FontCascade::Simple)
+                SET_REASON_AND_RETURN_IF_NEEDED(FlowHasComplexFontCodePath, reasons, includeReasons);
+        }
+
+        auto textReasons = canUseForText(textRenderer.stringView(), fontCascade, lineHeightConstraint, flowIsJustified, includeReasons);
+        if (textReasons != NoReason)
+            SET_REASON_AND_RETURN_IF_NEEDED(textReasons, reasons, includeReasons);
     }
-    const RenderStyle& style = flow.style();
-    if (style.textDecorationsInEffect() != TextDecorationNone)
-        return false;
-    if (style.textAlign() == JUSTIFY)
-        return false;
+    return reasons;
+}
+
+static AvoidanceReasonFlags canUseForStyle(const RenderStyle& style, IncludeReasons includeReasons)
+{
+    AvoidanceReasonFlags reasons = { };
+    if (style.textOverflow())
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasTextOverflow, reasons, includeReasons);
+    if ((style.textDecorationsInEffect() & TextDecorationUnderline) && style.textUnderlinePosition() == TextUnderlinePositionUnder)
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasUnsupportedUnderlineDecoration, reasons, includeReasons);
     // Non-visible overflow should be pretty easy to support.
     if (style.overflowX() != OVISIBLE || style.overflowY() != OVISIBLE)
-        return false;
-    if (!style.textIndent().isZero())
-        return false;
-    if (!style.wordSpacing().isZero() || style.letterSpacing())
-        return false;
-    if (style.textTransform() != TTNONE)
-        return false;
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasOverflowNotVisible, reasons, includeReasons);
     if (!style.isLeftToRightDirection())
-        return false;
-    if (style.lineBoxContain() != RenderStyle::initialLineBoxContain())
-        return false;
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowIsNotLTR, reasons, includeReasons);
+    if (!(style.lineBoxContain() & LineBoxContainBlock))
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasLineBoxContainProperty, reasons, includeReasons);
     if (style.writingMode() != TopToBottomWritingMode)
-        return false;
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowIsNotTopToBottom, reasons, includeReasons);
     if (style.lineBreak() != LineBreakAuto)
-        return false;
-    if (style.wordBreak() != NormalWordBreak)
-        return false;
-    if (style.unicodeBidi() != UBNormal || style.rtlOrdering() != LogicalOrder)
-        return false;
-    if (style.lineAlign() != LineAlignNone || style.lineSnap() != LineSnapNone)
-        return false;
-    if (style.hyphens() == HyphensAuto)
-        return false;
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasLineBreak, reasons, includeReasons);
+    if (style.unicodeBidi() != UBNormal)
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasNonNormalUnicodeBiDi, reasons, includeReasons);
+    if (style.rtlOrdering() != LogicalOrder)
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasRTLOrdering, reasons, includeReasons);
+    if (style.lineAlign() != LineAlignNone)
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasLineAlignEdges, reasons, includeReasons);
+    if (style.lineSnap() != LineSnapNone)
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasLineSnap, reasons, includeReasons);
     if (style.textEmphasisFill() != TextEmphasisFillFilled || style.textEmphasisMark() != TextEmphasisMarkNone)
-        return false;
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasTextEmphasisFillOrMark, reasons, includeReasons);
     if (style.textShadow())
-        return false;
-#if ENABLE(CSS_SHAPES)
-    if (style.resolvedShapeInside())
-        return true;
-#endif
-    if (style.textOverflow() || (flow.isAnonymousBlock() && flow.parent()->style().textOverflow()))
-        return false;
-    if (style.hasPseudoStyle(FIRST_LINE) || style.hasPseudoStyle(FIRST_LETTER))
-        return false;
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasTextShadow, reasons, includeReasons);
+    if (style.hasPseudoStyle(FIRST_LINE))
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasPseudoFirstLine, reasons, includeReasons);
+    if (style.hasPseudoStyle(FIRST_LETTER))
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasPseudoFirstLetter, reasons, includeReasons);
     if (style.hasTextCombine())
-        return false;
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasTextCombine, reasons, includeReasons);
     if (style.backgroundClip() == TextFillBox)
-        return false;
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasTextFillBox, reasons, includeReasons);
     if (style.borderFit() == BorderFitLines)
-        return false;
-    const RenderText& textRenderer = toRenderText(*flow.firstChild());
-    if (flow.containsFloats()) {
-        // We can't use the code path if any lines would need to be shifted below floats. This is because we don't keep per-line y coordinates.
-        // It is enough to test the first line width only as currently all floats must be overhanging.
-        if (textRenderer.minLogicalWidth() > LineWidth(const_cast<RenderBlockFlow&>(flow), false, DoNotIndentText).availableWidth())
-            return false;
-    }
-    if (textRenderer.isCombineText() || textRenderer.isCounter() || textRenderer.isQuote() || textRenderer.isTextFragment()
-#if ENABLE(SVG)
-        || textRenderer.isSVGInlineText()
-#endif
-        )
-        return false;
-    if (style.font().codePath(TextRun(textRenderer.text())) != Font::Simple)
-        return false;
-    if (style.font().isSVGFont())
-        return false;
-
-    // We assume that all lines have metrics based purely on the primary font.
-    auto& primaryFontData = *style.font().primaryFont();
-    if (primaryFontData.isLoading())
-        return false;
-    if (!canUseForText(textRenderer, primaryFontData))
-        return false;
-
-    return true;
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasBorderFitLines, reasons, includeReasons);
+    if (style.lineBreak() != LineBreakAuto)
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasNonAutoLineBreak, reasons, includeReasons);
+    if (style.nbspMode() != NBNORMAL)
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasWebKitNBSPMode, reasons, includeReasons);
+#if ENABLE(CSS_TRAILING_WORD)
+    if (style.trailingWord() != TrailingWord::Auto)
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasNonAutoTrailingWord, reasons, includeReasons);
 #endif
-}
-
-struct Style {
-    Style(const RenderStyle& style)
-        : font(style.font())
-        , textAlign(style.textAlign())
-        , collapseWhitespace(style.collapseWhiteSpace())
-        , preserveNewline(style.preserveNewline())
-        , wrapLines(style.autoWrap())
-        , breakWordOnOverflow(style.overflowWrap() == BreakOverflowWrap && (wrapLines || preserveNewline))
-        , spaceWidth(font.width(TextRun(&space, 1)))
-        , tabWidth(collapseWhitespace ? 0 : style.tabSize())
-    {
+    if (style.hyphens() == HyphensAuto) {
+        auto textReasons = canUseForText(style.hyphenString(), style.fontCascade(), std::nullopt, false, includeReasons);
+        if (textReasons != NoReason)
+            SET_REASON_AND_RETURN_IF_NEEDED(textReasons, reasons, includeReasons);
     }
-    const Font& font;
-    ETextAlign textAlign;
-    bool collapseWhitespace;
-    bool preserveNewline;
-    bool wrapLines;
-    bool breakWordOnOverflow;
-    float spaceWidth;
-    unsigned tabWidth;
-};
-
-static inline bool isWhitespace(UChar character, bool preserveNewline)
-{
-    return character == ' ' || character == '\t' || (!preserveNewline && character == '\n');
+    return reasons;
 }
 
-template <typename CharacterType>
-static inline unsigned skipWhitespaces(const CharacterType* text, unsigned offset, unsigned length, bool preserveNewline)
+AvoidanceReasonFlags canUseForWithReason(const RenderBlockFlow& flow, IncludeReasons includeReasons)
 {
-    for (; offset < length; ++offset) {
-        if (!isWhitespace(text[offset], preserveNewline))
-            return offset;
+#ifndef NDEBUG
+    static std::once_flag onceFlag;
+    std::call_once(onceFlag, [] {
+        registerNotifyCallback("com.apple.WebKit.showSimpleLineLayoutCoverage", printSimpleLineLayoutCoverage);
+        registerNotifyCallback("com.apple.WebKit.showSimpleLineLayoutReasons", printSimpleLineLayoutBlockList);
+        registerNotifyCallback("com.apple.WebKit.toggleSimpleLineLayout", toggleSimpleLineLayout);
+    });
+#endif
+    AvoidanceReasonFlags reasons = { };
+    if (!flow.settings().simpleLineLayoutEnabled())
+        SET_REASON_AND_RETURN_IF_NEEDED(FeatureIsDisabled, reasons, includeReasons);
+    if (!flow.parent())
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasNoParent, reasons, includeReasons);
+    if (!flow.firstChild())
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasNoChild, reasons, includeReasons);
+    if (flow.flowThreadState() != RenderObject::NotInsideFlowThread)
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowIsInsideRegion, reasons, includeReasons);
+    if (!flow.isHorizontalWritingMode())
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasHorizonalWritingMode, reasons, includeReasons);
+    if (flow.hasOutline())
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasOutline, reasons, includeReasons);
+    if (flow.isRubyText() || flow.isRubyBase())
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowIsRuby, reasons, includeReasons);
+    if (flow.style().hangingPunctuation() != NoHangingPunctuation)
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasHangingPunctuation, reasons, includeReasons);
+    
+    // Printing does pagination without a flow thread.
+    if (flow.document().paginated())
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowIsPaginated, reasons, includeReasons);
+    if (flow.firstLineBlock())
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasPseudoFirstLine, reasons, includeReasons);
+    if (flow.isAnonymousBlock() && flow.parent()->style().textOverflow())
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasTextOverflow, reasons, includeReasons);
+    if (flow.parent()->isDeprecatedFlexibleBox())
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowIsDepricatedFlexBox, reasons, includeReasons);
+    // FIXME: Placeholders do something strange.
+    if (is<RenderTextControl>(*flow.parent()) && downcast<RenderTextControl>(*flow.parent()).textFormControlElement().placeholderElement())
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowParentIsPlaceholderElement, reasons, includeReasons);
+    // FIXME: Implementation of wrap=hard looks into lineboxes.
+    if (flow.parent()->isTextArea() && flow.parent()->element()->hasAttributeWithoutSynchronization(HTMLNames::wrapAttr))
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowParentIsTextAreaWithWrapping, reasons, includeReasons);
+    // This currently covers <blockflow>#text</blockflow>, <blockflow>#text<br></blockflow> and mutiple (sibling) RenderText cases.
+    // The <blockflow><inline>#text</inline></blockflow> case is also popular and should be relatively easy to cover.
+    for (const auto* child = flow.firstChild(); child;) {
+        if (child->selectionState() != RenderObject::SelectionNone)
+            SET_REASON_AND_RETURN_IF_NEEDED(FlowChildIsSelected, reasons, includeReasons);
+        if (is<RenderText>(*child)) {
+            child = child->nextSibling();
+            continue;
+        }
+        if (is<RenderLineBreak>(child) && !downcast<RenderLineBreak>(*child).isWBR() && child->style().clear() == CNONE) {
+            child = child->nextSibling();
+            continue;
+        }
+        SET_REASON_AND_RETURN_IF_NEEDED(FlowHasNonSupportedChild, reasons, includeReasons);
+        break;
     }
-    return length;
+    auto styleReasons = canUseForStyle(flow.style(), includeReasons);
+    if (styleReasons != NoReason)
+        SET_REASON_AND_RETURN_IF_NEEDED(styleReasons, reasons, includeReasons);
+    // We can't use the code path if any lines would need to be shifted below floats. This is because we don't keep per-line y coordinates.
+    if (flow.containsFloats()) {
+        float minimumWidthNeeded = std::numeric_limits<float>::max();
+        for (const auto& textRenderer : childrenOfType<RenderText>(flow)) {
+            minimumWidthNeeded = std::min(minimumWidthNeeded, textRenderer.minLogicalWidth());
+
+            for (auto& floatingObject : *flow.floatingObjectSet()) {
+                ASSERT(floatingObject);
+                // if a float has a shape, we cannot tell if content will need to be shifted until after we lay it out,
+                // since the amount of space is not uniform for the height of the float.
+                if (floatingObject->renderer().shapeOutsideInfo())
+                    SET_REASON_AND_RETURN_IF_NEEDED(FlowHasUnsupportedFloat, reasons, includeReasons);
+                float availableWidth = flow.availableLogicalWidthForLine(floatingObject->y(), DoNotIndentText);
+                if (availableWidth < minimumWidthNeeded)
+                    SET_REASON_AND_RETURN_IF_NEEDED(FlowHasUnsupportedFloat, reasons, includeReasons);
+            }
+        }
+    }
+    auto fontAndTextReasons = canUseForFontAndText(flow, includeReasons);
+    if (fontAndTextReasons != NoReason)
+        SET_REASON_AND_RETURN_IF_NEEDED(fontAndTextReasons, reasons, includeReasons);
+    return reasons;
 }
 
-template <typename CharacterType>
-static float textWidth(const RenderText& renderText, const CharacterType* text, unsigned textLength, unsigned from, unsigned to, float xPosition, const Style& style)
+bool canUseFor(const RenderBlockFlow& flow)
 {
-    if (style.font.isFixedPitch() || (!from && to == textLength))
-        return renderText.width(from, to - from, style.font, xPosition, nullptr, nullptr);
-
-    TextRun run(text + from, to - from);
-    run.setXPos(xPosition);
-    run.setCharactersLength(textLength - from);
-    run.setTabSize(!!style.tabWidth, style.tabWidth);
-
-    ASSERT(run.charactersLength() >= run.length());
-
-    return style.font.width(run);
+    return canUseForWithReason(flow, IncludeReasons::First) == NoReason;
 }
 
-template <typename CharacterType>
-static float measureWord(unsigned start, unsigned end, float lineWidth, const Style& style, const CharacterType* text, unsigned textLength, const RenderText& textRenderer)
+static float computeLineLeft(ETextAlign textAlign, float availableWidth, float committedWidth, float logicalLeftOffset)
 {
-    if (text[start] == ' ' && end == start + 1)
-        return style.spaceWidth;
-
-    bool measureWithEndSpace = style.collapseWhitespace && end < textLength && text[end] == ' ';
-    if (measureWithEndSpace)
-        ++end;
-    float width = textWidth(textRenderer, text, textLength, start, end, lineWidth, style);
+    float remainingWidth = availableWidth - committedWidth;
+    float left = logicalLeftOffset;
+    switch (textAlign) {
+    case LEFT:
+    case WEBKIT_LEFT:
+    case TASTART:
+        return left;
+    case RIGHT:
+    case WEBKIT_RIGHT:
+    case TAEND:
+        return left + std::max<float>(remainingWidth, 0);
+    case CENTER:
+    case WEBKIT_CENTER:
+        return left + std::max<float>(remainingWidth / 2, 0);
+    case JUSTIFY:
+        ASSERT_NOT_REACHED();
+        break;
+    }
+    ASSERT_NOT_REACHED();
+    return 0;
+}
 
-    return measureWithEndSpace ? width - style.spaceWidth : width;
+static void revertAllRunsOnCurrentLine(Layout::RunVector& runs)
+{
+    while (!runs.isEmpty() && !runs.last().isEndOfLine)
+        runs.removeLast();
 }
 
-template <typename CharacterType>
-Vector<Run, 4> createLineRuns(unsigned lineStart, LineWidth& lineWidth, LazyLineBreakIterator& lineBreakIterator, const Style& style, const CharacterType* text, unsigned textLength, const RenderText& textRenderer)
+static void revertRuns(Layout::RunVector& runs, unsigned positionToRevertTo, float width)
 {
-    Vector<Run, 4> lineRuns;
-    lineRuns.uncheckedAppend(Run(lineStart, 0));
-
-    unsigned wordEnd = lineStart;
-    while (wordEnd < textLength) {
-        ASSERT(!style.collapseWhitespace || !isWhitespace(text[wordEnd], style.preserveNewline));
-
-        unsigned wordStart = wordEnd;
-
-        if (style.preserveNewline && text[wordStart] == '\n') {
-            ++wordEnd;
-            // FIXME: This creates a dedicated run for newline. This is wasteful and unnecessary but it keeps test results unchanged.
-            if (wordStart > lineStart)
-                lineRuns.append(Run(wordStart, lineRuns.last().right));
-            lineRuns.last().right = lineRuns.last().left;
-            lineRuns.last().end = wordEnd;
+    while (runs.size()) {
+        auto& lastRun = runs.last();
+        if (lastRun.end <= positionToRevertTo)
+            break;
+        if (lastRun.start >= positionToRevertTo) {
+            // Revert this run completely.
+            width -= (lastRun.logicalRight - lastRun.logicalLeft);
+            runs.removeLast();
+        } else {
+            lastRun.logicalRight -= width;
+            width = 0;
+            lastRun.end = positionToRevertTo;
+            // Partial removal.
             break;
         }
+    }
+}
 
-        if (!style.collapseWhitespace && isWhitespace(text[wordStart], style.preserveNewline))
-            wordEnd = wordStart + 1;
-        else
-            wordEnd = nextBreakablePosition<CharacterType, false>(lineBreakIterator, text, textLength, wordStart + 1);
-
-        bool wordIsPrecededByWhitespace = style.collapseWhitespace && wordStart > lineStart && isWhitespace(text[wordStart - 1], style.preserveNewline);
-        if (wordIsPrecededByWhitespace)
-            --wordStart;
+class LineState {
+public:
+    void setAvailableWidth(float width) { m_availableWidth = width; }
+    void setCollapedWhitespaceWidth(float width) { m_collapsedWhitespaceWidth = width; }
+    void setLogicalLeftOffset(float offset) { m_logicalLeftOffset = offset; }
+    void setOverflowedFragment(const TextFragmentIterator::TextFragment& fragment) { m_overflowedFragment = fragment; }
+    void setNeedsAllFragments()
+    {
+        ASSERT(!m_fragments);
+        m_fragments.emplace();
+    }
 
-        float wordWidth = measureWord(wordStart, wordEnd, lineWidth.committedWidth(), style, text, textLength, textRenderer);
+    float availableWidth() const { return m_availableWidth; }
+    float logicalLeftOffset() const { return m_logicalLeftOffset; }
+    const TextFragmentIterator::TextFragment& overflowedFragment() const { return m_overflowedFragment; }
+    bool hasTrailingWhitespace() const { return m_lastFragment.type() == TextFragmentIterator::TextFragment::Whitespace; }
+    TextFragmentIterator::TextFragment lastFragment() const { return m_lastFragment; }
+    bool isWhitespaceOnly() const { return m_trailingWhitespaceWidth && m_runsWidth == m_trailingWhitespaceWidth; }
+    bool fits(float extra) const { return m_availableWidth >= m_runsWidth + extra; }
+    bool firstCharacterFits() const { return m_firstCharacterFits; }
+    float width() const { return m_runsWidth; }
+    std::pair<unsigned, bool> expansionOpportunityCount(unsigned from, unsigned to) const
+    {
+        ASSERT(m_fragments);
+        // linebreak runs are special.
+        if (from == to)
+            return std::make_pair(0, false);
+        unsigned expansionOpportunityCount = 0;
+        auto previousFragmentType = TextFragmentIterator::TextFragment::ContentEnd;
+        for (const auto& fragment : *m_fragments) {
+            if (fragment.end() <= from)
+                continue;
+            auto currentFragmentType = fragment.type();
+            auto expansionOpportunity = this->expansionOpportunity(currentFragmentType, previousFragmentType);
+            if (expansionOpportunity)
+                ++expansionOpportunityCount;
+            previousFragmentType = currentFragmentType;
+            if (fragment.end() >= to)
+                return std::make_pair(expansionOpportunityCount, expansionOpportunity);
+        }
+        ASSERT_NOT_REACHED();
+        return std::make_pair(expansionOpportunityCount, false);
+    }
 
-        lineWidth.addUncommittedWidth(wordWidth);
+    bool isEmpty() const
+    {
+        if (!m_lastFragment.isValid())
+            return true;
+        if (!m_lastCompleteFragment.isEmpty())
+            return false;
+        return m_lastFragment.overlapsToNextRenderer();
+    }
 
-        if (style.wrapLines) {
-            // Move to the next line if the current one is full and we have something on it.
-            if (!lineWidth.fitsOnLine() && lineWidth.committedWidth())
-                break;
+    static inline unsigned endPositionForCollapsedFragment(const TextFragmentIterator::TextFragment& fragment)
+    {
+        return fragment.isCollapsed() ? fragment.start() + 1 : fragment.end();
+    }
 
-            // This is for white-space: pre-wrap which requires special handling for end line whitespace.
-            if (!style.collapseWhitespace && lineWidth.fitsOnLine() && wordEnd < textLength && isWhitespace(text[wordEnd], style.preserveNewline)) {
-                // Look ahead to see if the next whitespace would fit.
-                float whitespaceWidth = textWidth(textRenderer, text, textLength, wordEnd, wordEnd + 1, lineWidth.committedWidth(), style);
-                if (!lineWidth.fitsOnLineIncludingExtraWidth(whitespaceWidth)) {
-                    // If not eat away the rest of the whitespace on the line.
-                    unsigned whitespaceEnd = skipWhitespaces(text, wordEnd, textLength, style.preserveNewline);
-                    // Include newline to this run too.
-                    if (whitespaceEnd < textLength && text[whitespaceEnd] == '\n')
-                        ++whitespaceEnd;
-                    lineRuns.last().end = whitespaceEnd;
-                    lineRuns.last().right = lineWidth.availableWidth();
-                    break;
+    void appendFragmentAndCreateRunIfNeeded(const TextFragmentIterator::TextFragment& fragment, Layout::RunVector& runs)
+    {
+        // Adjust end position while collapsing.
+        unsigned endPosition = endPositionForCollapsedFragment(fragment);
+        // New line needs new run.
+        if (!m_runsWidth) {
+            ASSERT(!m_uncompletedWidth);
+            runs.append(Run(fragment.start(), endPosition, m_runsWidth, m_runsWidth + fragment.width(), false, fragment.hasHyphen()));
+        } else {
+            // Advance last completed fragment when the previous fragment is all set (including multiple parts across renderers)
+            if ((m_lastFragment.type() != fragment.type()) || !m_lastFragment.overlapsToNextRenderer()) {
+                m_lastCompleteFragment = m_lastFragment;
+                m_uncompletedWidth = fragment.width();
+            } else
+                m_uncompletedWidth += fragment.width();
+            // Collapse neighbouring whitespace, if they are across multiple renderers and are not collapsed yet.
+            if (m_lastFragment.isCollapsible() && fragment.isCollapsible()) {
+                ASSERT(m_lastFragment.isLastInRenderer());
+                if (!m_lastFragment.isCollapsed()) {
+                    // Line width needs to be adjusted so that now it takes collapsing into consideration.
+                    m_runsWidth -= (m_lastFragment.width() - m_collapsedWhitespaceWidth);
                 }
+                // This fragment is collapsed completely. No run is needed.
+                return;
+            }
+            if (m_lastFragment.isLastInRenderer() || m_lastFragment.isCollapsed())
+                runs.append(Run(fragment.start(), endPosition, m_runsWidth, m_runsWidth + fragment.width(), false, fragment.hasHyphen()));
+            else {
+                Run& lastRun = runs.last();
+                lastRun.end = endPosition;
+                lastRun.logicalRight += fragment.width();
+                ASSERT(!lastRun.hasHyphen);
+                lastRun.hasHyphen = fragment.hasHyphen();
             }
         }
+        m_runsWidth += fragment.width();
+        m_lastFragment = fragment;
+        if (m_fragments)
+            (*m_fragments).append(fragment);
+
+        if (fragment.type() == TextFragmentIterator::TextFragment::Whitespace)
+            m_trailingWhitespaceWidth += fragment.width();
+        else {
+            m_trailingWhitespaceWidth = 0;
+            m_lastNonWhitespaceFragment = fragment;
+        }
 
-        if (wordStart > lineRuns.last().end) {
-            // There were more than one consecutive whitespace.
-            ASSERT(wordIsPrecededByWhitespace);
-            // Include space to the end of the previous run.
-            lineRuns.last().end++;
-            lineRuns.last().right += style.spaceWidth;
-            // Start a new run on the same line.
-            lineRuns.append(Run(wordStart + 1, lineRuns.last().right));
+        if (!m_firstCharacterFits)
+            m_firstCharacterFits = fragment.start() + 1 > endPosition || m_runsWidth <= m_availableWidth;
+    }
+
+    TextFragmentIterator::TextFragment revertToLastCompleteFragment(Layout::RunVector& runs)
+    {
+        if (!m_uncompletedWidth) {
+            ASSERT(m_lastFragment == m_lastCompleteFragment);
+            return m_lastFragment;
         }
+        ASSERT(m_lastFragment.isValid());
+        m_runsWidth -= m_uncompletedWidth;
+        revertRuns(runs, endPositionForCollapsedFragment(m_lastCompleteFragment), m_uncompletedWidth);
+        m_uncompletedWidth = 0;
+        ASSERT(m_lastCompleteFragment.isValid());
+        return m_lastCompleteFragment;
+    }
 
-        if (!lineWidth.fitsOnLine() && style.breakWordOnOverflow) {
-            // Backtrack and start measuring character-by-character.
-            lineWidth.addUncommittedWidth(-lineWidth.uncommittedWidth());
-            unsigned splitEnd = wordStart;
-            for (; splitEnd < wordEnd; ++splitEnd) {
-                float charWidth = textWidth(textRenderer, text, textLength, splitEnd, splitEnd + 1, 0, style);
-                lineWidth.addUncommittedWidth(charWidth);
-                if (!lineWidth.fitsOnLine() && splitEnd > lineStart)
-                    break;
-                lineWidth.commit();
+    void removeTrailingWhitespace(Layout::RunVector& runs)
+    {
+        if (m_lastFragment.type() != TextFragmentIterator::TextFragment::Whitespace)
+            return;
+        if (m_lastNonWhitespaceFragment) {
+            auto needsReverting = m_lastNonWhitespaceFragment->end() != m_lastFragment.end();
+            // Trailing whitespace fragment might actually have zero length.
+            ASSERT(needsReverting || !m_trailingWhitespaceWidth);
+            if (needsReverting) {
+                revertRuns(runs, m_lastNonWhitespaceFragment->end(), m_trailingWhitespaceWidth);
+                m_runsWidth -= m_trailingWhitespaceWidth;
             }
-            lineRuns.last().end = splitEnd;
-            lineRuns.last().right = lineWidth.committedWidth();
-            // To match line boxes, set single-space-only line width to zero.
-            if (text[lineRuns.last().start] == ' ' && lineRuns.last().start + 1 == lineRuns.last().end)
-                lineRuns.last().right = lineRuns.last().left;
-            break;
+            m_trailingWhitespaceWidth = 0;
+            m_lastFragment = *m_lastNonWhitespaceFragment;
+            return;
         }
+        // This line is all whitespace.
+        revertAllRunsOnCurrentLine(runs);
+        m_runsWidth = 0;
+        m_trailingWhitespaceWidth = 0;
+        // FIXME: Make m_lastFragment optional.
+        m_lastFragment = TextFragmentIterator::TextFragment();
+    }
 
-        lineWidth.commit();
+private:
+    bool expansionOpportunity(TextFragmentIterator::TextFragment::Type currentFragmentType, TextFragmentIterator::TextFragment::Type previousFragmentType) const
+    {
+        return (currentFragmentType == TextFragmentIterator::TextFragment::Whitespace
+            || (currentFragmentType == TextFragmentIterator::TextFragment::NonWhitespace && previousFragmentType == TextFragmentIterator::TextFragment::NonWhitespace));
+    }
 
-        lineRuns.last().right = lineWidth.committedWidth();
-        lineRuns.last().end = wordEnd;
+    float m_availableWidth { 0 };
+    float m_logicalLeftOffset { 0 };
+    float m_runsWidth { 0 };
+    TextFragmentIterator::TextFragment m_overflowedFragment;
+    TextFragmentIterator::TextFragment m_lastFragment;
+    std::optional<TextFragmentIterator::TextFragment> m_lastNonWhitespaceFragment;
+    TextFragmentIterator::TextFragment m_lastCompleteFragment;
+    float m_uncompletedWidth { 0 };
+    float m_trailingWhitespaceWidth { 0 }; // Use this to remove trailing whitespace without re-mesuring the text.
+    float m_collapsedWhitespaceWidth { 0 };
+    // Having one character on the line does not necessarily mean it actually fits.
+    // First character of the first fragment might be forced on to the current line even if it does not fit.
+    bool m_firstCharacterFits { false };
+    std::optional<Vector<TextFragmentIterator::TextFragment, 30>> m_fragments;
+};
 
-        if (style.collapseWhitespace)
-            wordEnd = skipWhitespaces(text, wordEnd, textLength, style.preserveNewline);
+class FragmentForwardIterator : public std::iterator<std::forward_iterator_tag, unsigned> {
+public:
+    FragmentForwardIterator(unsigned fragmentIndex)
+        : m_fragmentIndex(fragmentIndex)
+    {
+    }
 
-        if (!lineWidth.fitsOnLine() && style.wrapLines) {
-            // The first run on the line overflows.
-            ASSERT(lineRuns.size() == 1);
-            break;
-        }
+    FragmentForwardIterator& operator++()
+    {
+        ++m_fragmentIndex;
+        return *this;
     }
-    return lineRuns;
+
+    bool operator!=(const FragmentForwardIterator& other) const { return m_fragmentIndex != other.m_fragmentIndex; }
+    bool operator==(const FragmentForwardIterator& other) const { return m_fragmentIndex == other.m_fragmentIndex; }
+    unsigned operator*() const { return m_fragmentIndex; }
+
+private:
+    unsigned m_fragmentIndex { 0 };
+};
+
+static FragmentForwardIterator begin(const TextFragmentIterator::TextFragment& fragment)  { return FragmentForwardIterator(fragment.start()); }
+static FragmentForwardIterator end(const TextFragmentIterator::TextFragment& fragment)  { return FragmentForwardIterator(fragment.end()); }
+
+static bool preWrap(const TextFragmentIterator::Style& style)
+{
+    return style.wrapLines && !style.collapseWhitespace;
+}
+    
+static void removeTrailingWhitespace(LineState& lineState, Layout::RunVector& runs, const TextFragmentIterator& textFragmentIterator)
+{
+    if (!lineState.hasTrailingWhitespace())
+        return;
+    // Remove collapsed whitespace, or non-collapsed pre-wrap whitespace, unless it's the only content on the line -so removing the whitesapce
+    // would produce an empty line.
+    const auto& style = textFragmentIterator.style();
+    bool collapseWhitespace = style.collapseWhitespace | preWrap(style);
+    if (!collapseWhitespace)
+        return;
+    if (preWrap(style) && lineState.isWhitespaceOnly())
+        return;
+    lineState.removeTrailingWhitespace(runs);
 }
 
-static float computeLineLeft(ETextAlign textAlign, const LineWidth& lineWidth)
+static void updateLineConstrains(const RenderBlockFlow& flow, LineState& line, const TextFragmentIterator::Style& style, bool isFirstLine)
 {
-    float remainingWidth = lineWidth.availableWidth() - lineWidth.committedWidth();
-    float left = lineWidth.logicalLeftOffset();
-    switch (textAlign) {
-    case LEFT:
-    case WEBKIT_LEFT:
-    case TASTART:
-        return left;
-    case RIGHT:
-    case WEBKIT_RIGHT:
-    case TAEND:
-        return left + std::max<float>(remainingWidth, 0);
-    case CENTER:
-    case WEBKIT_CENTER:
-        return left + std::max<float>(remainingWidth / 2, 0);
-    case JUSTIFY:
-        break;
-    }
-    ASSERT_NOT_REACHED();
-    return 0;
+    bool shouldApplyTextIndent = !flow.isAnonymous() || flow.parent()->firstChild() == &flow;
+    LayoutUnit height = flow.logicalHeight();
+    line.setLogicalLeftOffset(flow.logicalLeftOffsetForLine(height, DoNotIndentText) + (shouldApplyTextIndent && isFirstLine ? flow.textIndentOffset() : LayoutUnit(0)));
+    float logicalRightOffset = flow.logicalRightOffsetForLine(height, DoNotIndentText);
+    line.setAvailableWidth(std::max<float>(0, logicalRightOffset - line.logicalLeftOffset()));
+    if (style.textAlign == JUSTIFY)
+        line.setNeedsAllFragments();
 }
 
-static void adjustRunOffsets(Vector<Run, 4>& lineRuns, float adjustment)
+static std::optional<unsigned> hyphenPositionForFragment(unsigned splitPosition, TextFragmentIterator::TextFragment& fragmentToSplit,
+    const TextFragmentIterator& textFragmentIterator, float availableWidth, bool lineIsEmpty)
 {
-    if (!adjustment)
-        return;
-    for (unsigned i = 0; i < lineRuns.size(); ++i) {
-        lineRuns[i].left += adjustment;
-        lineRuns[i].right += adjustment;
+    auto& style = textFragmentIterator.style();
+    bool shouldHyphenate = style.shouldHyphenate && (!style.hyphenLimitLines || fragmentToSplit.wrappingWithHyphenCounter() < *style.hyphenLimitLines);
+    if (!shouldHyphenate)
+        return std::nullopt;
+
+    // FIXME: This is a workaround for webkit.org/b/169613. See maxPrefixWidth computation in tryHyphenating().
+    // It does not work properly with non-collapsed leading tabs when font is enlarged.
+    auto adjustedAvailableWidth = availableWidth - style.hyphenStringWidth;
+    if (!lineIsEmpty)
+        adjustedAvailableWidth += style.font.spaceWidth();
+    if (!enoughWidthForHyphenation(adjustedAvailableWidth, style.font.pixelSize()))
+        return std::nullopt;
+
+    // We might be able to fit the hyphen at the split position.
+    auto splitPositionWithHyphen = splitPosition;
+    // Find a splitting position where hyphen surely fits.
+    unsigned start = fragmentToSplit.start();
+    auto leftSideWidth = textFragmentIterator.textWidth(start, splitPosition, 0);
+    while (leftSideWidth + style.hyphenStringWidth > availableWidth) {
+        if (--splitPositionWithHyphen <= start)
+            return std::nullopt; // No space for hyphen.
+        leftSideWidth -= textFragmentIterator.textWidth(splitPositionWithHyphen, splitPositionWithHyphen + 1, 0);
     }
+    ASSERT(splitPositionWithHyphen > start);
+    return textFragmentIterator.lastHyphenPosition(fragmentToSplit, splitPositionWithHyphen + 1);
 }
 
-template <typename CharacterType>
-void createTextRuns(Layout::RunVector& runs, unsigned& lineCount, RenderBlockFlow& flow, RenderText& textRenderer)
+static TextFragmentIterator::TextFragment splitFragmentToFitLine(TextFragmentIterator::TextFragment& fragmentToSplit, float availableWidth, bool lineIsEmpty, const TextFragmentIterator& textFragmentIterator)
 {
-    const Style style(flow.style());
+    // FIXME: add surrogate pair support.
+    unsigned start = fragmentToSplit.start();
+    auto it = std::upper_bound(begin(fragmentToSplit), end(fragmentToSplit), availableWidth, [&textFragmentIterator, start](float availableWidth, unsigned index) {
+        // FIXME: use the actual left position of the line (instead of 0) to calculated width. It might give false width for tab characters.
+        return availableWidth < textFragmentIterator.textWidth(start, index + 1, 0);
+    });
+    unsigned splitPosition = (*it);
+    // Does first character fit this line?
+    if (splitPosition == start) {
+        if (lineIsEmpty)
+            ++splitPosition;
+    } else if (auto hyphenPosition = hyphenPositionForFragment(splitPosition, fragmentToSplit, textFragmentIterator, availableWidth, lineIsEmpty))
+        return fragmentToSplit.splitWithHyphen(*hyphenPosition, textFragmentIterator);
+    return fragmentToSplit.split(splitPosition, textFragmentIterator);
+}
 
-    const CharacterType* text = textRenderer.text()->getCharacters<CharacterType>();
-    const unsigned textLength = textRenderer.textLength();
+enum PreWrapLineBreakRule { Preserve, Ignore };
 
-    LayoutUnit borderAndPaddingBefore = flow.borderAndPaddingBefore();
-    LayoutUnit lineHeight = lineHeightFromFlow(flow);
+static TextFragmentIterator::TextFragment consumeLineBreakIfNeeded(const TextFragmentIterator::TextFragment& fragment, TextFragmentIterator& textFragmentIterator, LineState& line, Layout::RunVector& runs,
+    PreWrapLineBreakRule preWrapLineBreakRule = PreWrapLineBreakRule::Preserve)
+{
+    if (!fragment.isLineBreak())
+        return fragment;
+
+    if (preWrap(textFragmentIterator.style()) && preWrapLineBreakRule != PreWrapLineBreakRule::Ignore)
+        return fragment;
 
-    LazyLineBreakIterator lineBreakIterator(textRenderer.text(), flow.style().locale());
+    // <br> always produces a run. (required by testing output)
+    if (fragment.type() == TextFragmentIterator::TextFragment::HardLineBreak)
+        line.appendFragmentAndCreateRunIfNeeded(fragment, runs);
+    return textFragmentIterator.nextTextFragment();
+}
 
-    unsigned lineEnd = 0;
-    while (lineEnd < textLength) {
-        if (style.collapseWhitespace)
-            lineEnd = skipWhitespaces(text, lineEnd, textLength, style.preserveNewline);
+static TextFragmentIterator::TextFragment skipWhitespaceIfNeeded(const TextFragmentIterator::TextFragment& fragment, TextFragmentIterator& textFragmentIterator)
+{
+    if (!textFragmentIterator.style().collapseWhitespace)
+        return fragment;
 
-        unsigned lineStart = lineEnd;
+    TextFragmentIterator::TextFragment firstNonWhitespaceFragment = fragment;
+    while (firstNonWhitespaceFragment.type() == TextFragmentIterator::TextFragment::Whitespace)
+        firstNonWhitespaceFragment = textFragmentIterator.nextTextFragment();
+    return firstNonWhitespaceFragment;
+}
 
-        // LineWidth reads the current y position from the flow so keep it updated.
-        flow.setLogicalHeight(lineHeight * lineCount + borderAndPaddingBefore);
-        LineWidth lineWidth(flow, false, DoNotIndentText);
+static TextFragmentIterator::TextFragment firstFragment(TextFragmentIterator& textFragmentIterator, LineState& currentLine, const LineState& previousLine, Layout::RunVector& runs)
+{
+    // Handle overflowed fragment from previous line.
+    TextFragmentIterator::TextFragment firstFragment(previousLine.overflowedFragment());
+
+    if (firstFragment.isEmpty())
+        firstFragment = textFragmentIterator.nextTextFragment();
+    else if (firstFragment.type() == TextFragmentIterator::TextFragment::Whitespace && preWrap(textFragmentIterator.style()) && previousLine.firstCharacterFits()) {
+        // Special overflow pre-wrap whitespace handling: skip the overflowed whitespace (even when style says not-collapsible) if we managed to fit at least one character on the previous line.
+        firstFragment = textFragmentIterator.nextTextFragment();
+        // If skipping the whitespace puts us on a newline, skip the newline too as we already wrapped the line.
+        firstFragment = consumeLineBreakIfNeeded(firstFragment, textFragmentIterator, currentLine, runs, PreWrapLineBreakRule::Ignore);
+    }
+    return skipWhitespaceIfNeeded(firstFragment, textFragmentIterator);
+}
 
-        auto lineRuns = createLineRuns(lineStart, lineWidth, lineBreakIterator, style, text, textLength, textRenderer);
+static void forceFragmentToLine(LineState& line, TextFragmentIterator& textFragmentIterator, Layout::RunVector& runs, const TextFragmentIterator::TextFragment& fragment)
+{
+    line.appendFragmentAndCreateRunIfNeeded(fragment, runs);
+    // Check if there are more fragments to add to the current line.
+    auto nextFragment = textFragmentIterator.nextTextFragment();
+    if (fragment.overlapsToNextRenderer()) {
+        while (true) {
+            if (nextFragment.type() != fragment.type())
+                break;
+            line.appendFragmentAndCreateRunIfNeeded(nextFragment, runs);
+            // Does it overlap to the next segment?
+            if (!nextFragment.overlapsToNextRenderer())
+                return;
+            nextFragment = textFragmentIterator.nextTextFragment();
+        }
+    }
+    // When the forced fragment is followed by either whitespace and/or line break, consume them too, otherwise we end up with an extra whitespace and/or line break.
+    nextFragment = skipWhitespaceIfNeeded(nextFragment, textFragmentIterator);
+    nextFragment = consumeLineBreakIfNeeded(nextFragment, textFragmentIterator, line, runs);
+    line.setOverflowedFragment(nextFragment);
+}
 
-        lineEnd = lineRuns.last().end;
-        if (lineStart == lineEnd)
-            continue;
+static bool createLineRuns(LineState& line, const LineState& previousLine, Layout::RunVector& runs, TextFragmentIterator& textFragmentIterator)
+{
+    const auto& style = textFragmentIterator.style();
+    line.setCollapedWhitespaceWidth(style.font.spaceWidth() + style.wordSpacing);
+    bool lineCanBeWrapped = style.wrapLines || style.breakFirstWordOnOverflow || style.breakAnyWordOnOverflow;
+    auto fragment = firstFragment(textFragmentIterator, line, previousLine, runs);
+    while (fragment.type() != TextFragmentIterator::TextFragment::ContentEnd) {
+        // Hard linebreak.
+        if (fragment.isLineBreak()) {
+            // Add the new line fragment only if there's nothing on the line. (otherwise the extra new line character would show up at the end of the content.)
+            if (line.isEmpty() || fragment.type() == TextFragmentIterator::TextFragment::HardLineBreak) {
+                if (style.textAlign == RIGHT || style.textAlign == WEBKIT_RIGHT)
+                    line.removeTrailingWhitespace(runs);
+                line.appendFragmentAndCreateRunIfNeeded(fragment, runs);
+            }
+            break;
+        }
+        if (lineCanBeWrapped && !line.fits(fragment.width())) {
+            // Overflow wrapping behaviour:
+            // 1. Whitesapce collapse on: whitespace is skipped. Jump to next line.
+            // 2. Whitespace collapse off: whitespace is wrapped.
+            // 3. First, non-whitespace fragment is either wrapped or kept on the line. (depends on overflow-wrap)
+            // 5. Non-whitespace fragment when there's already another fragment on the line either gets wrapped (word-break: break-all)
+            // or gets pushed to the next line.
+            bool emptyLine = line.isEmpty();
+            // Whitespace fragment.
+            if (fragment.type() == TextFragmentIterator::TextFragment::Whitespace) {
+                if (!style.collapseWhitespace) {
+                    // Split the fragment; (modified)fragment stays on this line, overflowedFragment is pushed to next line.
+                    line.setOverflowedFragment(splitFragmentToFitLine(fragment, line.availableWidth() - line.width(), emptyLine, textFragmentIterator));
+                    line.appendFragmentAndCreateRunIfNeeded(fragment, runs);
+                }
+                // When whitespace collapse is on, whitespace that doesn't fit is simply skipped.
+                break;
+            }
+            // Non-whitespace fragment. (!style.wrapLines: bug138102(preserve existing behavior)
+            if (((emptyLine && style.breakFirstWordOnOverflow) || style.breakAnyWordOnOverflow) || !style.wrapLines) {
+                // Split the fragment; (modified)fragment stays on this line, overflowedFragment is pushed to next line.
+                line.setOverflowedFragment(splitFragmentToFitLine(fragment, line.availableWidth() - line.width(), emptyLine, textFragmentIterator));
+                line.appendFragmentAndCreateRunIfNeeded(fragment, runs);
+                break;
+            }
+            ASSERT(fragment.type() == TextFragmentIterator::TextFragment::NonWhitespace);
+            // Find out if this non-whitespace fragment has a hyphen where we can break.
+            if (style.shouldHyphenate) {
+                auto fragmentToSplit = fragment;
+                // Split and check if we actually ended up with a hyphen.
+                auto overflowFragment = splitFragmentToFitLine(fragmentToSplit, line.availableWidth() - line.width(), emptyLine, textFragmentIterator);
+                if (fragmentToSplit.hasHyphen()) {
+                    line.setOverflowedFragment(overflowFragment);
+                    line.appendFragmentAndCreateRunIfNeeded(fragmentToSplit, runs);
+                    break;
+                }
+                // No hyphen, no split.
+            }
+            // Non-breakable non-whitespace first fragment. Add it to the current line. -it overflows though.
+            if (emptyLine) {
+                forceFragmentToLine(line, textFragmentIterator, runs, fragment);
+                break;
+            }
+            // Non-breakable non-whitespace fragment when there's already content on the line. Push it to the next line.
+            ASSERT(line.lastFragment().isValid());
+            if (line.lastFragment().overlapsToNextRenderer()) {
+                // Check if this fragment is a continuation of a previous segment. In such cases, we need to remove them all.
+                textFragmentIterator.revertToEndOfFragment(line.revertToLastCompleteFragment(runs));
+                break;
+            }
+            line.setOverflowedFragment(fragment);
+            break;
+        }
+        line.appendFragmentAndCreateRunIfNeeded(fragment, runs);
+        // Find the next text fragment.
+        fragment = textFragmentIterator.nextTextFragment(line.width());
+    }
+    return (fragment.type() == TextFragmentIterator::TextFragment::ContentEnd && line.overflowedFragment().isEmpty()) || line.overflowedFragment().type() == TextFragmentIterator::TextFragment::ContentEnd;
+}
 
-        lineRuns.last().isEndOfLine = true;
+static ExpansionBehavior expansionBehavior(bool isAfterExpansion, bool lastRunOnLine)
+{
+    ExpansionBehavior expansionBehavior;
+    expansionBehavior = isAfterExpansion ? ForbidLeadingExpansion : AllowLeadingExpansion;
+    expansionBehavior |= lastRunOnLine ? ForbidTrailingExpansion : AllowTrailingExpansion;
+    return expansionBehavior;
+}
 
-        float lineLeft = computeLineLeft(style.textAlign, lineWidth);
-        adjustRunOffsets(lineRuns, lineLeft);
+static void justifyRuns(const LineState& line, Layout::RunVector& runs, unsigned firstRunIndex)
+{
+    ASSERT(runs.size());
+    auto widthToDistribute = line.availableWidth() - line.width();
+    if (widthToDistribute <= 0)
+        return;
 
-        for (unsigned i = 0; i < lineRuns.size(); ++i)
-            runs.append(lineRuns[i]);
+    auto lastRunIndex = runs.size() - 1;
+    ASSERT(firstRunIndex <= lastRunIndex);
+    Vector<std::pair<unsigned, ExpansionBehavior>> expansionOpportunityList;
+    unsigned expansionOpportunityCountOnThisLine = 0;
+    auto isAfterExpansion = true;
+    for (auto i = firstRunIndex; i <= lastRunIndex; ++i) {
+        const auto& run = runs.at(i);
+        unsigned opportunityCountInRun = 0;
+        std::tie(opportunityCountInRun, isAfterExpansion) = line.expansionOpportunityCount(run.start, run.end);
+        expansionOpportunityList.append(std::make_pair(opportunityCountInRun, expansionBehavior(isAfterExpansion, i == lastRunIndex)));
+        expansionOpportunityCountOnThisLine += opportunityCountInRun;
+    }
+    if (!expansionOpportunityCountOnThisLine)
+        return;
 
-        ++lineCount;
+    ASSERT(expansionOpportunityList.size() == lastRunIndex - firstRunIndex + 1);
+    auto expansion = widthToDistribute / expansionOpportunityCountOnThisLine;
+    float accumulatedExpansion = 0;
+    for (auto i = firstRunIndex; i <= lastRunIndex; ++i) {
+        auto& run = runs.at(i);
+        unsigned opportunityCountInRun;
+        std::tie(opportunityCountInRun, run.expansionBehavior) = expansionOpportunityList.at(i - firstRunIndex);
+        run.expansion = opportunityCountInRun * expansion;
+        run.logicalLeft += accumulatedExpansion;
+        run.logicalRight += (accumulatedExpansion + run.expansion);
+        accumulatedExpansion += run.expansion;
     }
 }
 
-std::unique_ptr<Layout> create(RenderBlockFlow& flow)
+static ETextAlign textAlignForLine(const TextFragmentIterator::Style& style, bool lastLine)
 {
-    Layout::RunVector runs;
-    unsigned lineCount = 0;
-
-    RenderText& textRenderer = toRenderText(*flow.firstChild());
-    ASSERT(!textRenderer.firstTextBox());
+    // Fallback to LEFT (START) alignment for non-collapsable content and for the last line before a forced break or the end of the block.
+    auto textAlign = style.textAlign;
+    if (textAlign == JUSTIFY && (!style.collapseWhitespace || lastLine))
+        textAlign = LEFT;
+    return textAlign;
+}
 
-    if (textRenderer.is8Bit())
-        createTextRuns<LChar>(runs, lineCount, flow, textRenderer);
+static void closeLineEndingAndAdjustRuns(LineState& line, Layout::RunVector& runs, std::optional<unsigned> lastRunIndexOfPreviousLine, unsigned& lineCount,
+    const TextFragmentIterator& textFragmentIterator, bool lastLineInFlow)
+{
+    if (!runs.size() || (lastRunIndexOfPreviousLine && runs.size() - 1 == lastRunIndexOfPreviousLine.value()))
+        return;
+    removeTrailingWhitespace(line, runs, textFragmentIterator);
+    if (!runs.size())
+        return;
+    // Adjust runs' position by taking line's alignment into account.
+    const auto& style = textFragmentIterator.style();
+    auto firstRunIndex = lastRunIndexOfPreviousLine ? lastRunIndexOfPreviousLine.value() + 1 : 0;
+    auto lineLogicalLeft = line.logicalLeftOffset();
+    auto textAlign = textAlignForLine(style, lastLineInFlow || (line.lastFragment().isValid() && line.lastFragment().type() == TextFragmentIterator::TextFragment::HardLineBreak));
+    if (textAlign == JUSTIFY)
+        justifyRuns(line, runs, firstRunIndex);
     else
-        createTextRuns<UChar>(runs, lineCount, flow, textRenderer);
+        lineLogicalLeft = computeLineLeft(textAlign, line.availableWidth(), line.width(), line.logicalLeftOffset());
+    for (auto i = firstRunIndex; i < runs.size(); ++i) {
+        runs[i].logicalLeft += lineLogicalLeft;
+        runs[i].logicalRight += lineLogicalLeft;
+    }
+    runs.last().isEndOfLine = true;
+    ++lineCount;
+}
 
-    textRenderer.clearNeedsLayout();
+static void createTextRuns(Layout::RunVector& runs, RenderBlockFlow& flow, unsigned& lineCount)
+{
+    LayoutUnit borderAndPaddingBefore = flow.borderAndPaddingBefore();
+    LayoutUnit lineHeight = lineHeightFromFlow(flow);
+    LineState line;
+    bool isEndOfContent = false;
+    TextFragmentIterator textFragmentIterator = TextFragmentIterator(flow);
+    std::optional<unsigned> lastRunIndexOfPreviousLine;
+    do {
+        flow.setLogicalHeight(lineHeight * lineCount + borderAndPaddingBefore);
+        LineState previousLine = line;
+        line = LineState();
+        updateLineConstrains(flow, line, textFragmentIterator.style(), !lineCount);
+        isEndOfContent = createLineRuns(line, previousLine, runs, textFragmentIterator);
+        closeLineEndingAndAdjustRuns(line, runs, lastRunIndexOfPreviousLine, lineCount, textFragmentIterator, isEndOfContent);
+        if (runs.size())
+            lastRunIndexOfPreviousLine = runs.size() - 1;
+    } while (!isEndOfContent);
+}
 
+std::unique_ptr<Layout> create(RenderBlockFlow& flow)
+{
+    unsigned lineCount = 0;
+    Layout::RunVector runs;
+    createTextRuns(runs, flow, lineCount);
     return Layout::create(runs, lineCount);
 }
 
-- 
cgit v1.2.1