Refactor BreakingContext::handleText

third_party/WebKit/Source/core/layout/line/BreakingContextInlineHeaders.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All right reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 54 matching lines @@
         , m_lineInfo(inLineInfo)
         , m_layoutTextInfo(inLayoutTextInfo)
         , m_lastFloatFromPreviousLine(inLastFloatFromPreviousLine)
         , m_width(lineWidth)
         , m_currWS(NORMAL)
         , m_lastWS(NORMAL)
         , m_preservesNewline(false)
         , m_atStart(true)
         , m_ignoringSpaces(false)
         , m_currentCharacterIsSpace(false)
-        , m_currentCharacterShouldCollapseIfPreWap(false)
+        , m_currentCharacterShouldCollapseIfPreWrap(false)
         , m_appliedStartWidth(appliedStartWidth)
         , m_includeEndWidth(true)
         , m_autoWrap(false)
         , m_autoWrapWasEverTrueOnLine(false)
         , m_floatsFitOnLine(true)
         , m_collapseWhiteSpace(false)
         , m_startingNewParagraph(m_lineInfo.previousLineBrokeCleanly())
         , m_allowImagesToBreak(!block.document().inQuirksMode() || !block.isTableCell() || !m_blockStyle->logicalWidth().isIntrinsicOrAuto())
         , m_atEnd(false)
         , m_lineMidpointState(resolver.midpointState())
     {
         m_lineInfo.setPreviousLineBrokeCleanly(false);
     }
 
     LayoutObject* currentObject() { return m_current.object(); }
     InlineIterator lineBreak() { return m_lineBreak; }
     bool atEnd() { return m_atEnd; }
 
     void initializeForCurrentObject();
 
     void increment();
 
     void handleBR(EClear&);
     void handleOutOfFlowPositioned(Vector<LineLayoutBox>& positionedObjects);
     void handleFloat();
     void handleEmptyInline();
     void handleReplaced();
     bool handleText(WordMeasurements&, bool& hyphenated);
+    void prepareForNextCharacter(const LineLayoutText&, bool& prohibitBreakInside, bool previousCharacterIsSpace, bool previousCharacterShouldCollapseIfPreWap);
+    bool canBreakAtWhitespace(bool breakWords, WordMeasurement&, bool stoppedIgnoringSpaces, bool& hyphenated, float charWidth, float& hyphenWidth, bool betweenWords, bool midWordBreak, bool breakAll, bool previousCharacterIsSpace, float lastWidthMeasurement, const LineLayoutText&, const Font&, bool applyWordSpacing, float wordSpacing);
+    bool trailingSpaceExceedsAvailableWidth(bool midWordBreak, const LineLayoutText&, WordMeasurement&, bool applyWordSpacing, bool wordSpacing, const Font&);
+    WordMeasurement& calculateWordWidth(WordMeasurements&, LineLayoutText&, float lastSpace, float& lastWidthMeasurement, float wordSpacingForWordMeasurement, const Font&, float wordTrailingSpaceWidth, UChar);
+    void stopIgnoringSpaces(unsigned& lastSpace);
     void commitAndUpdateLineBreakIfNeeded();
     InlineIterator handleEndOfLine();
 
     void clearLineBreakIfFitsOnLine()
     {
         if (m_width.fitsOnLine() || m_lastWS == NOWRAP)
             m_lineBreak.clear();
     }
 
 private:
@@ skipping 20 matching lines @@
 
     LineWidth m_width;
 
     EWhiteSpace m_currWS;
     EWhiteSpace m_lastWS;
 
     bool m_preservesNewline;
     bool m_atStart;
     bool m_ignoringSpaces;
     bool m_currentCharacterIsSpace;
-    bool m_currentCharacterShouldCollapseIfPreWap;
+    bool m_currentCharacterShouldCollapseIfPreWrap;
     bool m_appliedStartWidth;
     bool m_includeEndWidth;
     bool m_autoWrap;
     bool m_autoWrapWasEverTrueOnLine;
     bool m_floatsFitOnLine;
     bool m_collapseWhiteSpace;
     bool m_startingNewParagraph;
     bool m_allowImagesToBreak;
     bool m_atEnd;
 
@@ skipping 287 matching lines @@
             m_lineInfo.setEmpty(false, m_block, &m_width);
         if (m_ignoringSpaces) {
             // If we are in a run of ignored spaces then ensure we get a linebox if lineboxes are eventually
             // created for the line...
             m_trailingObjects.clear();
             ensureLineBoxInsideIgnoredSpaces(&m_lineMidpointState, m_current.object());
         } else if (m_blockStyle->collapseWhiteSpace() && m_resolver.position().object() == m_current.object()
             && shouldSkipWhitespaceAfterStartObject(m_block, m_current.object(), m_lineMidpointState)) {
             // If this object is at the start of the line, we need to behave like list markers and
             // start ignoring spaces.
-            m_currentCharacterShouldCollapseIfPreWap = m_currentCharacterIsSpace = true;
+            m_currentCharacterShouldCollapseIfPreWrap = m_currentCharacterIsSpace = true;
             m_ignoringSpaces = true;
         } else {
             // If we are after a trailing space but aren't ignoring spaces yet then ensure we get a linebox
             // if we encounter collapsible whitepace.
             m_trailingObjects.appendObjectIfNeeded(m_current.object());
         }
     }
 
     m_width.addUncommittedWidth((inlineLogicalWidthFromAncestorsIfNeeded(m_current.object()) + borderPaddingMarginStart(flowBox) + borderPaddingMarginEnd(flowBox)).toFloat());
 }
@@ skipping 11 matching lines @@
         && (!m_current.object().isRubyRun() || toLayoutRubyRun(m_current.object())->canBreakBefore(m_layoutTextInfo.m_lineBreakIterator))) {
         m_width.commit();
         m_lineBreak.moveToStartOf(m_current.object());
     }
 
     if (m_ignoringSpaces)
         m_lineMidpointState.stopIgnoringSpaces(InlineIterator(0, m_current.object(), 0));
 
     m_lineInfo.setEmpty(false, m_block, &m_width);
     m_ignoringSpaces = false;
-    m_currentCharacterShouldCollapseIfPreWap = m_currentCharacterIsSpace = false;
+    m_currentCharacterShouldCollapseIfPreWrap = m_currentCharacterIsSpace = false;
     m_trailingObjects.clear();
 
     // Optimize for a common case. If we can't find whitespace after the list
     // item, then this is all moot.
     LayoutUnit replacedLogicalWidth = m_block.logicalWidthForChild(replacedBox) + m_block.marginStartForChild(replacedBox) + m_block.marginEndForChild(replacedBox) + inlineLogicalWidthFromAncestorsIfNeeded(m_current.object());
     if (m_current.object().isListMarker()) {
         if (m_blockStyle->collapseWhiteSpace() && shouldSkipWhitespaceAfterStartObject(m_block, m_current.object(), m_lineMidpointState)) {
             // Like with inline flows, we start ignoring spaces to make sure that any
             // additional spaces we see will be discarded.
-            m_currentCharacterShouldCollapseIfPreWap = m_currentCharacterIsSpace = true;
+            m_currentCharacterShouldCollapseIfPreWrap = m_currentCharacterIsSpace = true;
             m_ignoringSpaces = true;
         }
         if (LineLayoutListMarker(m_current.object()).isInside())
             m_width.addUncommittedWidth(replacedLogicalWidth.toFloat());
     } else {
         m_width.addUncommittedWidth(replacedLogicalWidth.toFloat());
     }
     if (m_current.object().isRubyRun())
         m_width.applyOverhang(LineLayoutRubyRun(m_current.object()), m_lastObject, m_nextObject);
     // Update prior line break context characters, using U+FFFD (OBJECT REPLACEMENT CHARACTER) for replaced element.
@@ skipping 33 matching lines @@
     return font.width(run, fallbackFonts, glyphBounds);
 }
 
 inline bool BreakingContext::handleText(WordMeasurements& wordMeasurements, bool& hyphenated)
 {
     if (!m_current.offset())
         m_appliedStartWidth = false;
 
     LineLayoutText layoutText(m_current.object());
 
-    bool isSVGText = layoutText.isSVGInlineText();
-
     // If we have left a no-wrap inline and entered an autowrap inline while ignoring spaces
     // then we need to mark the start of the autowrap inline as a potential linebreak now.
     if (m_autoWrap && !ComputedStyle::autoWrap(m_lastWS) && m_ignoringSpaces) {
         m_width.commit();
         m_lineBreak.moveToStartOf(m_current.object());
     }
 
     const ComputedStyle& style = layoutText.styleRef(m_lineInfo.isFirstLine());
     const Font& font = style.font();
 
@@ skipping 13 matching lines @@
     bool prohibitBreakInside = m_currentStyle->hasTextCombine() && layoutText.isCombineText() && LineLayoutTextCombine(layoutText).isCombined();
 
     // This is currently only used for word-break: break-all, specifically for the case
     // where we have a break opportunity within a word, then a string of non-breakable
     // content that ends up making our word wider than the current line.
     // See: fast/css3-text/css3-word-break/word-break-all-wrap-with-floats.html
     float widthMeasurementAtLastBreakOpportunity = 0;
 
     float hyphenWidth = 0;
 
-    if (isSVGText) {
+    if (layoutText.isSVGInlineText()) {
         breakWords = false;
         breakAll = false;
         keepAll = false;
     }
 
     if (layoutText.isWordBreak()) {
         m_width.commit();
         m_lineBreak.moveToStartOf(m_current.object());
         ASSERT(m_current.offset() == layoutText.textLength());
     }
 
     if (m_layoutTextInfo.m_text != layoutText) {
         m_layoutTextInfo.m_text = layoutText;
         m_layoutTextInfo.m_font = &font;
         m_layoutTextInfo.m_lineBreakIterator.resetStringAndReleaseIterator(layoutText.text(), style.locale());
     } else if (m_layoutTextInfo.m_font != &font) {
         m_layoutTextInfo.m_font = &font;
     }
 
     // Non-zero only when kerning is enabled, in which case we measure
     // words with their trailing space, then subtract its width.
     float wordTrailingSpaceWidth = (font.fontDescription().typesettingFeatures() & Kerning) ?
         font.width(constructTextRun(font, &spaceCharacter, 1, style, style.direction())) + wordSpacing
         : 0;
 
     UChar lastCharacter = m_layoutTextInfo.m_lineBreakIterator.lastCharacter();
     UChar secondToLastCharacter = m_layoutTextInfo.m_lineBreakIterator.secondToLastCharacter();
     for (; m_current.offset() < layoutText.textLength(); m_current.fastIncrementInTextNode()) {
         bool previousCharacterIsSpace = m_currentCharacterIsSpace;
-        bool previousCharacterShouldCollapseIfPreWap = m_currentCharacterShouldCollapseIfPreWap;
+        bool previousCharacterShouldCollapseIfPreWap = m_currentCharacterShouldCollapseIfPreWrap;
         UChar c = m_current.current();
-        m_currentCharacterShouldCollapseIfPreWap = m_currentCharacterIsSpace = c == spaceCharacter || c == tabulationCharacter || (!m_preservesNewline && (c == newlineCharacter));
+        m_currentCharacterShouldCollapseIfPreWrap = m_currentCharacterIsSpace = c == spaceCharacter || c == tabulationCharacter || (!m_preservesNewline && (c == newlineCharacter));
 
         if (!m_collapseWhiteSpace || !m_currentCharacterIsSpace)
             m_lineInfo.setEmpty(false, m_block, &m_width);
 
         if (c == softHyphenCharacter && m_autoWrap && !hyphenWidth) {
             hyphenWidth = layoutText.hyphenWidth(font, textDirectionFromUnicode(m_resolver.position().direction()));
             m_width.addUncommittedWidth(hyphenWidth);
         }
 
         bool applyWordSpacing = false;
 
+        // Determine if we should try breaking in the middle of a word.
         if (breakWords && !midWordBreak) {
             widthFromLastBreakingOpportunity += charWidth;
             bool midWordBreakIsBeforeSurrogatePair = U16_IS_LEAD(c) && m_current.offset() + 1 < layoutText.textLength() && U16_IS_TRAIL(layoutText.uncheckedCharacterAt(m_current.offset() + 1));
             charWidth = textWidth(layoutText, m_current.offset(), midWordBreakIsBeforeSurrogatePair ? 2 : 1, font, m_width.committedWidth() + widthFromLastBreakingOpportunity, m_collapseWhiteSpace);
             midWordBreak = m_width.committedWidth() + widthFromLastBreakingOpportunity + charWidth > m_width.availableWidth();
         }
 
+        // Determine if we are in the whitespace between words.
         int nextBreakablePosition = m_current.nextBreakablePosition();
         bool betweenWords = c == newlineCharacter || (m_currWS != PRE && !m_atStart && m_layoutTextInfo.m_lineBreakIterator.isBreakable(m_current.offset(), nextBreakablePosition, breakAll ? LineBreakType::BreakAll : keepAll ? LineBreakType::KeepAll : LineBreakType::Normal));
         m_current.setNextBreakablePosition(nextBreakablePosition);
 
-        if (betweenWords || midWordBreak) {
-            bool stoppedIgnoringSpaces = false;
+        // if we're in the middle of a word or at the start of a new one and can't break there then continue to the next character.
+        if (!betweenWords && !midWordBreak) {
             if (m_ignoringSpaces) {
-                lastSpaceWordSpacing = 0;
-                if (!m_currentCharacterIsSpace) {
-                    // Stop ignoring spaces and begin at this
-                    // new point.
-                    m_ignoringSpaces = false;
-                    wordSpacingForWordMeasurement = 0;
-                    lastSpace = m_current.offset(); // e.g., "Foo    goo", don't add in any of the ignored spaces.
-                    m_lineMidpointState.stopIgnoringSpaces(InlineIterator(0, m_current.object(), m_current.offset()));
-                    stoppedIgnoringSpaces = true;
-                } else {
-                    // Just keep ignoring these spaces.
-                    nextCharacter(c, lastCharacter, secondToLastCharacter);
-                    continue;
-                }
+                lastSpaceWordSpacing = applyWordSpacing ? wordSpacing : 0;
+                wordSpacingForWordMeasurement = (applyWordSpacing && wordMeasurements.last().width) ? wordSpacing : 0;
+                stopIgnoringSpaces(lastSpace);
             }
-
-            wordMeasurements.grow(wordMeasurements.size() + 1);
-            WordMeasurement& wordMeasurement = wordMeasurements.last();
-
-            wordMeasurement.layoutText = layoutText;
-            wordMeasurement.endOffset = m_current.offset();
-            wordMeasurement.startOffset = lastSpace;
-
-            float lastWidthMeasurement;
-            if (wordTrailingSpaceWidth && c == spaceCharacter)
-                lastWidthMeasurement = textWidth(layoutText, lastSpace, m_current.offset() + 1 - lastSpace, font, m_width.currentWidth(), m_collapseWhiteSpace, &wordMeasurement.fallbackFonts, &wordMeasurement.glyphBounds) - wordTrailingSpaceWidth;
-            else
-                lastWidthMeasurement = textWidth(layoutText, lastSpace, m_current.offset() - lastSpace, font, m_width.currentWidth(), m_collapseWhiteSpace, &wordMeasurement.fallbackFonts, &wordMeasurement.glyphBounds);
-
-            wordMeasurement.width = lastWidthMeasurement + wordSpacingForWordMeasurement;
-            wordMeasurement.glyphBounds.move(wordSpacingForWordMeasurement, 0);
-            lastWidthMeasurement += lastSpaceWordSpacing;
-            m_width.addUncommittedWidth(lastWidthMeasurement);
-
-            if (m_collapseWhiteSpace && previousCharacterIsSpace && m_currentCharacterIsSpace && lastWidthMeasurement)
-                m_width.setTrailingWhitespaceWidth(lastWidthMeasurement);
-
-            if (!m_appliedStartWidth) {
-                m_width.addUncommittedWidth(inlineLogicalWidthFromAncestorsIfNeeded(m_current.object(), true, false).toFloat());
-                m_appliedStartWidth = true;
-            }
-
-            applyWordSpacing = wordSpacing && m_currentCharacterIsSpace;
-
-            if (!m_width.committedWidth() && m_autoWrap && !m_width.fitsOnLine() && !widthMeasurementAtLastBreakOpportunity)
-                m_width.fitBelowFloats(m_lineInfo.isFirstLine());
-
-            if (m_autoWrap || breakWords) {
-                // If we break only after white-space, consider the current character
-                // as candidate width for this line.
-                bool lineWasTooWide = false;
-                if (m_width.fitsOnLine() && m_currentCharacterIsSpace && m_currentStyle->breakOnlyAfterWhiteSpace() && !midWordBreak) {
-                    float charWidth = textWidth(layoutText, m_current.offset(), 1, font, m_width.currentWidth(), m_collapseWhiteSpace, &wordMeasurement.fallbackFonts, &wordMeasurement.glyphBounds) + (applyWordSpacing ? wordSpacing : 0);
-                    // Check if line is too big even without the extra space
-                    // at the end of the line. If it is not, do nothing.
-                    // If the line needs the extra whitespace to be too long,
-                    // then move the line break to the space and skip all
-                    // additional whitespace.
-                    if (!m_width.fitsOnLine(charWidth)) {
-                        lineWasTooWide = true;
-                        m_lineBreak.moveTo(m_current.object(), m_current.offset(), m_current.nextBreakablePosition());
-                        skipTrailingWhitespace(m_lineBreak, m_lineInfo);
-                    }
-                }
-                if (lineWasTooWide || !m_width.fitsOnLine()) {
-                    if (m_lineBreak.atTextParagraphSeparator()) {
-                        if (!stoppedIgnoringSpaces && m_current.offset() > 0)
-                            m_lineMidpointState.ensureCharacterGetsLineBox(m_current);
-                        m_lineBreak.increment();
-                        m_lineInfo.setPreviousLineBrokeCleanly(true);
-                        wordMeasurement.endOffset = m_lineBreak.offset();
-                    }
-                    if (m_lineBreak.object() && m_lineBreak.offset() && m_lineBreak.object().isText() && LineLayoutText(m_lineBreak.object()).textLength() && LineLayoutText(m_lineBreak.object()).characterAt(m_lineBreak.offset() - 1) == softHyphenCharacter)
-                        hyphenated = true;
-                    if (m_lineBreak.offset() && m_lineBreak.offset() != (unsigned)wordMeasurement.endOffset && !wordMeasurement.width) {
-                        if (charWidth) {
-                            wordMeasurement.endOffset = m_lineBreak.offset();
-                            wordMeasurement.width = charWidth;
-                        }
-                    }
-                    // Didn't fit. Jump to the end unless there's still an opportunity to collapse whitespace.
-                    if (m_ignoringSpaces || !m_collapseWhiteSpace || !m_currentCharacterIsSpace || !previousCharacterIsSpace) {
-                        m_atEnd = true;
-                        return false;
-                    }
-                } else {
-                    if (!betweenWords || (midWordBreak && !m_autoWrap) || (breakAll && !m_currentCharacterIsSpace))
-                        m_width.addUncommittedWidth(-lastWidthMeasurement);
-                    if (hyphenWidth) {
-                        // Subtract the width of the soft hyphen out since we fit on a line.
-                        m_width.addUncommittedWidth(-hyphenWidth);
-                        hyphenWidth = 0;
-                    }
-                }
-            }
-
-            if (c == newlineCharacter && m_preservesNewline) {
-                if (!stoppedIgnoringSpaces && m_current.offset())
-                    m_lineMidpointState.ensureCharacterGetsLineBox(m_current);
-                m_lineBreak.moveTo(m_current.object(), m_current.offset(), m_current.nextBreakablePosition());
-                m_lineBreak.increment();
-                m_lineInfo.setPreviousLineBrokeCleanly(true);
-                return true;
-            }
-
-            if (m_autoWrap && betweenWords) {
-                m_width.commit();
-                widthFromLastBreakingOpportunity = 0;
-                m_lineBreak.moveTo(m_current.object(), m_current.offset(), m_current.nextBreakablePosition());
-                // Auto-wrapping text should not wrap in the middle of a word once it has had an
-                // opportunity to break after a word.
-                breakWords = false;
-                widthMeasurementAtLastBreakOpportunity = lastWidthMeasurement;
-            }
-
-            if (midWordBreak && !U16_IS_TRAIL(c) && !(WTF::Unicode::category(c) & (WTF::Unicode::Mark_NonSpacing | WTF::Unicode::Mark_Enclosing | WTF::Unicode::Mark_SpacingCombining))) {
-                // Remember this as a breakable position in case
-                // adding the end width forces a break.
-                m_lineBreak.moveTo(m_current.object(), m_current.offset(), m_current.nextBreakablePosition());
-                midWordBreak &= (breakWords || breakAll);
-            }
-
-            if (betweenWords) {
-                lastSpaceWordSpacing = applyWordSpacing ? wordSpacing : 0;
-                wordSpacingForWordMeasurement = (applyWordSpacing && wordMeasurement.width) ? wordSpacing : 0;
-                lastSpace = !breakAll || m_currentCharacterIsSpace ? m_current.offset() : lastSpace;
-            }
-
-            if (!m_ignoringSpaces && m_currentStyle->collapseWhiteSpace()) {
-                // If we encounter a newline, or if we encounter a
-                // second space, we need to go ahead and break up this
-                // run and enter a mode where we start collapsing spaces.
-                if (m_currentCharacterIsSpace && previousCharacterIsSpace) {
-                    m_ignoringSpaces = true;
-
-                    // We just entered a mode where we are ignoring
-                    // spaces. Create a midpoint to terminate the run
-                    // before the second space.
-                    m_lineMidpointState.startIgnoringSpaces(m_startOfIgnoredSpaces);
-                    m_trailingObjects.updateMidpointsForTrailingObjects(m_lineMidpointState, InlineIterator(), TrailingObjects::DoNotCollapseFirstSpace);
-                }
-            }
-        } else if (m_ignoringSpaces) {
-            // Stop ignoring spaces and begin at this
-            // new point.
-            m_ignoringSpaces = false;
-            lastSpaceWordSpacing = applyWordSpacing ? wordSpacing : 0;
-            wordSpacingForWordMeasurement = (applyWordSpacing && wordMeasurements.last().width) ? wordSpacing : 0;
-            lastSpace = m_current.offset(); // e.g., "Foo    goo", don't add in any of the ignored spaces.
-            m_lineMidpointState.stopIgnoringSpaces(InlineIterator(0, m_current.object(), m_current.offset()));
+            prepareForNextCharacter(layoutText, prohibitBreakInside, previousCharacterIsSpace, previousCharacterShouldCollapseIfPreWap);
+            m_atStart = false;
+            nextCharacter(c, lastCharacter, secondToLastCharacter);
+            continue;
         }
 
-        if (isSVGText && m_current.offset()) {
-            // Force creation of new InlineBoxes for each absolute positioned character (those that start new text chunks).
-            if (LineLayoutSVGInlineText(layoutText).characterStartsNewTextChunk(m_current.offset()))
-                m_lineMidpointState.ensureCharacterGetsLineBox(m_current);
+        // If we're ignoring space and we're at a collapsible space such as a space or tab, continue to the next character.
+        bool stoppedIgnoringSpaces = false;
+        if (m_ignoringSpaces && m_currentCharacterIsSpace) {
+            lastSpaceWordSpacing = 0;
+            // Just keep ignoring these spaces.
+            nextCharacter(c, lastCharacter, secondToLastCharacter);
+            continue;
         }
 
-        if (prohibitBreakInside) {
-            m_current.setNextBreakablePosition(layoutText.textLength());
-            prohibitBreakInside = false;
+        // So we're in the first whitespace after a word or in whitespace that we don't collapse, which means we may have a breaking opportunity here.
+
+        // If we're here and we're ignoring spaces then the current character isn't a space, it's some of other form of whitespace. Stop ignoring spaces.
+        if (m_ignoringSpaces) {
+            lastSpaceWordSpacing = 0;
+            wordSpacingForWordMeasurement = 0;
+            stoppedIgnoringSpaces = true;
+            stopIgnoringSpaces(lastSpace);
         }
 
-        if (m_currentCharacterIsSpace && !previousCharacterIsSpace) {
-            m_startOfIgnoredSpaces.setObject(m_current.object());
-            m_startOfIgnoredSpaces.setOffset(m_current.offset());
+        // Update our tally of the width since the last breakable position with the width of the word we're now at the end of.
+        float lastWidthMeasurement;
+        WordMeasurement& wordMeasurement = calculateWordWidth(wordMeasurements, layoutText, lastSpace, lastWidthMeasurement, wordSpacingForWordMeasurement, font, wordTrailingSpaceWidth, c);
+        lastWidthMeasurement += lastSpaceWordSpacing;
+        m_width.addUncommittedWidth(lastWidthMeasurement);
+
+        // We keep track of the total width contributed by trailing space as we often want to exclude it when determining
+        // if a run fits on a line.
+        if (m_collapseWhiteSpace && previousCharacterIsSpace && m_currentCharacterIsSpace && lastWidthMeasurement)
+            m_width.setTrailingWhitespaceWidth(lastWidthMeasurement);
+
+        // If this is the end of the first word in run of text then make sure we apply the width from any leading inlines.
+        // For example: '<span style="margin-left: 5px;"><span style="margin-left: 10px;">FirstWord</span></span>' would
+        // apply a width of 15px from the two span ancestors.
+        if (!m_appliedStartWidth) {
+            m_width.addUncommittedWidth(inlineLogicalWidthFromAncestorsIfNeeded(m_current.object(), true, false).toFloat());
+            m_appliedStartWidth = true;
         }
 
-        if (!m_currentCharacterIsSpace && previousCharacterShouldCollapseIfPreWap) {
-            if (m_autoWrap && m_currentStyle->breakOnlyAfterWhiteSpace())
-                m_lineBreak.moveTo(m_current.object(), m_current.offset(), m_current.nextBreakablePosition());
+        // If we haven't hit a breakable position yet and already don't fit on the line try to move below any floats.
+        if (!m_width.committedWidth() && m_autoWrap && !m_width.fitsOnLine() && !widthMeasurementAtLastBreakOpportunity)
+            m_width.fitBelowFloats(m_lineInfo.isFirstLine());
+
+        // If there is a soft-break available at this whitespace position then take it.
+        applyWordSpacing = wordSpacing && m_currentCharacterIsSpace;
+        if (canBreakAtWhitespace(breakWords, wordMeasurement, stoppedIgnoringSpaces, hyphenated, charWidth, hyphenWidth, betweenWords, midWordBreak, breakAll, previousCharacterIsSpace, lastWidthMeasurement, layoutText, font, applyWordSpacing, wordSpacing))
+            return false;
+
+        // If there is a hard-break available at this whitespace position then take it.
+        if (c == newlineCharacter && m_preservesNewline) {
+            if (!stoppedIgnoringSpaces && m_current.offset())
+                m_lineMidpointState.ensureCharacterGetsLineBox(m_current);
+            m_lineBreak.moveTo(m_current.object(), m_current.offset(), m_current.nextBreakablePosition());
+            m_lineBreak.increment();
+            m_lineInfo.setPreviousLineBrokeCleanly(true);
+            return true;
         }
 
-        if (m_collapseWhiteSpace && m_currentCharacterIsSpace && !m_ignoringSpaces)
-            m_trailingObjects.setTrailingWhitespace(LineLayoutText(m_current.object()));
-        else if (!m_currentStyle->collapseWhiteSpace() || !m_currentCharacterIsSpace)
-            m_trailingObjects.clear();
+        // Auto-wrapping text should not wrap in the middle of a word once it has had an
+        // opportunity to break after a word.
+        if (m_autoWrap && betweenWords) {
+            m_width.commit();
+            widthFromLastBreakingOpportunity = 0;
+            m_lineBreak.moveTo(m_current.object(), m_current.offset(), m_current.nextBreakablePosition());
+            breakWords = false;
+            widthMeasurementAtLastBreakOpportunity = lastWidthMeasurement;
+        }
 
+        // Remember this as a breakable position in case adding the end width forces a break.
+        if (midWordBreak && !U16_IS_TRAIL(c) && !(WTF::Unicode::category(c) & (WTF::Unicode::Mark_NonSpacing | WTF::Unicode::Mark_Enclosing | WTF::Unicode::Mark_SpacingCombining))) {
+            m_lineBreak.moveTo(m_current.object(), m_current.offset(), m_current.nextBreakablePosition());
+            midWordBreak &= (breakWords || breakAll);
+        }
+
+        if (betweenWords) {
+            lastSpaceWordSpacing = applyWordSpacing ? wordSpacing : 0;
+            wordSpacingForWordMeasurement = (applyWordSpacing && wordMeasurement.width) ? wordSpacing : 0;
+            lastSpace = !breakAll || m_currentCharacterIsSpace ? m_current.offset() : lastSpace;
+        }
+
+        // If we encounter a newline, or if we encounter a second space, we need to go ahead and break up this run and enter a mode where we start collapsing spaces.
+        if (!m_ignoringSpaces && m_currentStyle->collapseWhiteSpace()) {
+            if (m_currentCharacterIsSpace && previousCharacterIsSpace) {
+                m_ignoringSpaces = true;
+                // We just entered a mode where we are ignoring spaces. Create a midpoint to terminate the run  before the second space.

[kojii, 2015/12/08 08:02:10]

nit: two spaces between "run" and "before".

+                m_lineMidpointState.startIgnoringSpaces(m_startOfIgnoredSpaces);
+                m_trailingObjects.updateMidpointsForTrailingObjects(m_lineMidpointState, InlineIterator(), TrailingObjects::DoNotCollapseFirstSpace);
+            }
+        }
+
+        prepareForNextCharacter(layoutText, prohibitBreakInside, previousCharacterIsSpace, previousCharacterShouldCollapseIfPreWap);
         m_atStart = false;
         nextCharacter(c, lastCharacter, secondToLastCharacter);
     }
 
     m_layoutTextInfo.m_lineBreakIterator.setPriorContext(lastCharacter, secondToLastCharacter);
 
     wordMeasurements.grow(wordMeasurements.size() + 1);
     WordMeasurement& wordMeasurement = wordMeasurements.last();
     wordMeasurement.layoutText = layoutText;
 
@@ skipping 23 matching lines @@
             return true;
         }
         if (!hyphenated && m_lineBreak.previousInSameNode() == softHyphenCharacter) {
             hyphenated = true;
             m_atEnd = true;
         }
     }
     return false;
 }
 
+inline void BreakingContext::stopIgnoringSpaces(unsigned& lastSpace)
+{
+    m_ignoringSpaces = false;
+    lastSpace = m_current.offset(); // e.g., "Foo    goo", don't add in any of the ignored spaces.
+    m_lineMidpointState.stopIgnoringSpaces(InlineIterator(0, m_current.object(), m_current.offset()));
+}
+
+inline WordMeasurement& BreakingContext::calculateWordWidth(WordMeasurements& wordMeasurements, LineLayoutText& layoutText, float lastSpace, float& lastWidthMeasurement, float wordSpacingForWordMeasurement, const Font& font, float wordTrailingSpaceWidth, UChar c)

[kojii, 2015/12/08 08:02:10]

Shouldn't lastSpace be unsigned rather than float?

+{
+    wordMeasurements.grow(wordMeasurements.size() + 1);
+    WordMeasurement& wordMeasurement = wordMeasurements.last();
+    wordMeasurement.layoutText = layoutText;
+    wordMeasurement.endOffset = m_current.offset();
+    wordMeasurement.startOffset = lastSpace;
+
+    if (wordTrailingSpaceWidth && c == spaceCharacter)
+        lastWidthMeasurement = textWidth(layoutText, lastSpace, m_current.offset() + 1 - lastSpace, font, m_width.currentWidth(), m_collapseWhiteSpace, &wordMeasurement.fallbackFonts, &wordMeasurement.glyphBounds) - wordTrailingSpaceWidth;
+    else
+        lastWidthMeasurement = textWidth(layoutText, lastSpace, m_current.offset() - lastSpace, font, m_width.currentWidth(), m_collapseWhiteSpace, &wordMeasurement.fallbackFonts, &wordMeasurement.glyphBounds);
+
+    wordMeasurement.width = lastWidthMeasurement + wordSpacingForWordMeasurement;
+    wordMeasurement.glyphBounds.move(wordSpacingForWordMeasurement, 0);
+    return wordMeasurement;
+}
+
+inline bool BreakingContext::trailingSpaceExceedsAvailableWidth(bool midWordBreak, const LineLayoutText& layoutText, WordMeasurement& wordMeasurement, bool applyWordSpacing, bool wordSpacing, const Font& font)
+{
+    // If we break only after white-space, consider the current character
+    // as candidate width for this line.
+    if (m_width.fitsOnLine() && m_currentCharacterIsSpace && m_currentStyle->breakOnlyAfterWhiteSpace() && !midWordBreak) {
+        float charWidth = textWidth(layoutText, m_current.offset(), 1, font, m_width.currentWidth(), m_collapseWhiteSpace, &wordMeasurement.fallbackFonts, &wordMeasurement.glyphBounds) + (applyWordSpacing ? wordSpacing : 0);
+        // Check if line is too big even without the extra space
+        // at the end of the line. If it is not, do nothing.
+        // If the line needs the extra whitespace to be too long,
+        // then move the line break to the space and skip all
+        // additional whitespace.
+        if (!m_width.fitsOnLine(charWidth)) {
+            m_lineBreak.moveTo(m_current.object(), m_current.offset(), m_current.nextBreakablePosition());
+            skipTrailingWhitespace(m_lineBreak, m_lineInfo);
+            return true;
+        }
+    }
+    return false;
+}
+
+inline bool BreakingContext::canBreakAtWhitespace(bool breakWords, WordMeasurement& wordMeasurement, bool stoppedIgnoringSpaces, bool& hyphenated, float charWidth, float& hyphenWidth, bool betweenWords, bool midWordBreak, bool breakAll, bool previousCharacterIsSpace, float lastWidthMeasurement, const LineLayoutText& layoutText, const Font& font, bool applyWordSpacing, float wordSpacing)
+{
+    if (!m_autoWrap && !breakWords)
+        return false;
+
+    // If we break only after white-space, consider the current character
+    // as candidate width for this line.
+    if (trailingSpaceExceedsAvailableWidth(midWordBreak, layoutText, wordMeasurement, applyWordSpacing, wordSpacing, font) || !m_width.fitsOnLine()) {
+        if (m_lineBreak.atTextParagraphSeparator()) {
+            if (!stoppedIgnoringSpaces && m_current.offset() > 0)
+                m_lineMidpointState.ensureCharacterGetsLineBox(m_current);
+            m_lineBreak.increment();
+            m_lineInfo.setPreviousLineBrokeCleanly(true);
+            wordMeasurement.endOffset = m_lineBreak.offset();
+        }
+        if (m_lineBreak.object() && m_lineBreak.offset() && m_lineBreak.object().isText() && LineLayoutText(m_lineBreak.object()).textLength() && LineLayoutText(m_lineBreak.object()).characterAt(m_lineBreak.offset() - 1) == softHyphenCharacter)
+            hyphenated = true;
+        if (m_lineBreak.offset() && m_lineBreak.offset() != (unsigned)wordMeasurement.endOffset && !wordMeasurement.width) {
+            if (charWidth) {
+                wordMeasurement.endOffset = m_lineBreak.offset();
+                wordMeasurement.width = charWidth;
+            }
+        }
+        // Didn't fit. Jump to the end unless there's still an opportunity to collapse whitespace.
+        if (m_ignoringSpaces || !m_collapseWhiteSpace || !m_currentCharacterIsSpace || !previousCharacterIsSpace) {
+            m_atEnd = true;
+            return true;
+        }
+    } else {
+        if (!betweenWords || (midWordBreak && !m_autoWrap) || (breakAll && !m_currentCharacterIsSpace))
+            m_width.addUncommittedWidth(-lastWidthMeasurement);
+        if (hyphenWidth) {
+            // Subtract the width of the soft hyphen out since we fit on a line.
+            m_width.addUncommittedWidth(-hyphenWidth);
+            hyphenWidth = 0;
+        }
+    }
+    return false;
+}
+
+inline void BreakingContext::prepareForNextCharacter(const LineLayoutText& layoutText, bool& prohibitBreakInside, bool previousCharacterIsSpace, bool previousCharacterShouldCollapseIfPreWap)
+{
+    if (layoutText.isSVGInlineText() && m_current.offset()) {
+        // Force creation of new InlineBoxes for each absolute positioned character (those that start new text chunks).
+        if (LineLayoutSVGInlineText(layoutText).characterStartsNewTextChunk(m_current.offset()))
+            m_lineMidpointState.ensureCharacterGetsLineBox(m_current);
+    }
+
+    if (prohibitBreakInside) {
+        m_current.setNextBreakablePosition(layoutText.textLength());
+        prohibitBreakInside = false;
+    }
+
+    if (m_currentCharacterIsSpace && !previousCharacterIsSpace) {
+        m_startOfIgnoredSpaces.setObject(m_current.object());
+        m_startOfIgnoredSpaces.setOffset(m_current.offset());
+    }
+
+    if (!m_currentCharacterIsSpace && previousCharacterShouldCollapseIfPreWap) {
+        if (m_autoWrap && m_currentStyle->breakOnlyAfterWhiteSpace())
+            m_lineBreak.moveTo(m_current.object(), m_current.offset(), m_current.nextBreakablePosition());
+    }
+
+    if (m_collapseWhiteSpace && m_currentCharacterIsSpace && !m_ignoringSpaces)
+        m_trailingObjects.setTrailingWhitespace(LineLayoutText(m_current.object()));
+    else if (!m_currentStyle->collapseWhiteSpace() || !m_currentCharacterIsSpace)
+        m_trailingObjects.clear();
+}
+
 inline void BreakingContext::commitAndUpdateLineBreakIfNeeded()
 {
     bool checkForBreak = m_autoWrap;
     if (m_width.committedWidth() && !m_width.fitsOnLine() && m_lineBreak.object() && m_currWS == NOWRAP) {
         checkForBreak = true;
     } else if (m_nextObject && m_current.object().isText() && m_nextObject.isText() && !m_nextObject.isBR() && (m_autoWrap || m_nextObject.style()->autoWrap())) {
         if (m_autoWrap && m_currentCharacterIsSpace) {
             checkForBreak = true;
         } else {
             LineLayoutText nextText(m_nextObject);
@@ skipping 62 matching lines @@
 
     if (style.textIndentType() == TextIndentHanging)
         shouldIndentText = shouldIndentText == IndentText ? DoNotIndentText : IndentText;
 
     return shouldIndentText;
 }
 
 }
 
 #endif // BreakingContextInlineHeaders_h