Prevent to measure the whole word when break-all

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 98 matching lines @@
     InlineIterator handleEndOfLine();
 
     void clearLineBreakIfFitsOnLine()
     {
         if (m_width.fitsOnLine() || m_lastWS == NOWRAP)
             m_lineBreak.clear();
     }
 
 private:
     void skipTrailingWhitespace(InlineIterator&, const LineInfo&);
+    bool shouldMidWordBreak(UChar, LineLayoutText, const Font&,
+        float& charWidth, float& widthFromLastBreakingOpportunity,
+        bool breakAll, int& nextBreakablePositionForBreakAll);
     bool rewindToMidWordBreak(WordMeasurement&, int end, float width);
     bool rewindToFirstMidWordBreak(LineLayoutText, const ComputedStyle&, const Font&, bool breakAll, WordMeasurement&);
     bool rewindToMidWordBreak(LineLayoutText, const ComputedStyle&, const Font&, bool breakAll, WordMeasurement&);
     bool hyphenate(LineLayoutText, const ComputedStyle&, const Font&, const Hyphenation&, float lastSpaceWordSpacing, WordMeasurement&);
 
     InlineBidiResolver& m_resolver;
 
     InlineIterator m_current;
     InlineIterator m_lineBreak;
     InlineIterator m_startOfIgnoredSpaces;
@@ skipping 406 matching lines @@
 {
     if ((!from && len == text.textLength()) || text.style()->hasTextCombine())
         return text.width(from, len, font, LayoutUnit(xPos), text.style()->direction(), fallbackFonts, glyphBounds);
 
     TextRun run = constructTextRun(font, text, from, len, text.styleRef());
     run.setTabSize(!collapseWhiteSpace, text.style()->getTabSize());
     run.setXPos(xPos);
     return font.width(run, fallbackFonts, glyphBounds);
 }
 
+ALWAYS_INLINE bool BreakingContext::shouldMidWordBreak(
+    UChar c, LineLayoutText layoutText, const Font& font,
+    float& charWidth, float& widthFromLastBreakingOpportunity,
+    bool breakAll, int& nextBreakablePositionForBreakAll)
+{
+    // For breakWords/breakAll, we need to measure up to normal break
+    // opportunity and then rewindToMidWordBreak() because ligatures/kerning can
+    // shorten the width as we add more characters.
+    // However, doing so can hit the performance when a "word" is really long,
+    // such as minimized JS, because the next line will re-shape the rest of the
+    // word in the current architecture.
+    // This function is a heuristic optimization to stop at 2em overflow.
+    float overflowAllowance = 2 * font.getFontDescription().computedSize();
+
+    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);
+    if (m_width.committedWidth() + widthFromLastBreakingOpportunity + charWidth <= m_width.availableWidth() + overflowAllowance)
+        return false;
+

[kojii, 2016/07/05 11:37:58]

Up to this point in this function is just a move from handleText(). The
following logic is the additional one.

+    // breakAll has different break opportunities. Ensure we break only at
+    // breakAll allows to break.
+    if (breakAll &&
+        !m_layoutTextInfo.m_lineBreakIterator.isBreakable(m_current.offset(), nextBreakablePositionForBreakAll, LineBreakType::BreakAll)) {
+        return false;
+    }
+
+    return true;
+}
+
 ALWAYS_INLINE int lastBreakablePositionForBreakAll(LineLayoutText text,
     const ComputedStyle& style, int start, int end)
 {
     LazyLineBreakIterator lineBreakIterator(text.text(), style.locale());
     int lastBreakablePosition = 0, nextBreakablePosition = -1;
     for (int i = start; ;i = nextBreakablePosition + 1) {
         lineBreakIterator.isBreakable(i, nextBreakablePosition, LineBreakType::BreakAll);
         if (nextBreakablePosition == end)
             return end;
         if (nextBreakablePosition < 0 || nextBreakablePosition > end)
@@ skipping 153 matching lines @@
     if (layoutText.isSVGInlineText()) {
         breakWords = false;
         breakAll = false;
         keepAll = false;
     }
 
     // Use LineBreakType::Normal for break-all. When a word does not fit,
     // rewindToMidWordBreak() finds the mid-word break point.
     LineBreakType lineBreakType = keepAll ? LineBreakType::KeepAll : LineBreakType::Normal;
     bool canBreakMidWord = breakAll || breakWords;
+    int nextBreakablePositionForBreakAll = -1;
 
     if (layoutText.isWordBreak()) {
         m_width.commit();
         m_lineBreak.moveToStartOf(m_current.getLineLayoutItem());
         ASSERT(m_current.offset() == layoutText.textLength());
     }
 
     if (m_layoutTextInfo.m_text != layoutText) {
         m_layoutTextInfo.m_text = layoutText;
         m_layoutTextInfo.m_font = &font;
@@ skipping 21 matching lines @@
         }
 
         if (c == softHyphenCharacter && m_autoWrap && !hyphenWidth && !disableSoftHyphen) {
             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 && !U16_IS_TRAIL(c)) {
-            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);
-            // Measure up to 2em overflow since ligatures/kerning can shorten
-            // the width as we add more characters. rewindToMidWordBreak() can
-            // measure the accurate mid-word break point then.
-            midWordBreak = m_width.committedWidth() + widthFromLastBreakingOpportunity + charWidth > m_width.availableWidth()
-                + 2 * font.getFontDescription().computedSize();
-        }
+        if (canBreakMidWord && !midWordBreak && !U16_IS_TRAIL(c))
+            midWordBreak = shouldMidWordBreak(c, layoutText, font, charWidth, widthFromLastBreakingOpportunity, breakAll, nextBreakablePositionForBreakAll);
 
         // 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, lineBreakType)
             && (!disableSoftHyphen || m_current.previousInSameNode() != softHyphenCharacter));
         m_current.setNextBreakablePosition(nextBreakablePosition);
 
         // 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) {
@@ skipping 41 matching lines @@
             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.getLineLayoutItem(), true, false).toFloat());
             m_appliedStartWidth = true;
         }
 
-        // 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());
-
         midWordBreak = false;
         if (!m_width.fitsOnLine()) {
             if (canBreakMidWord) {
                 m_width.addUncommittedWidth(-wordMeasurement.width);
                 if (rewindToMidWordBreak(layoutText, style, font, breakAll, wordMeasurement)) {
                     lastWidthMeasurement = wordMeasurement.width + lastSpaceWordSpacing;
                     midWordBreak = true;
                 }
                 m_width.addUncommittedWidth(wordMeasurement.width);
             } else if (hyphenation) {
                 m_width.addUncommittedWidth(-wordMeasurement.width);
                 DCHECK(lastSpace == static_cast<unsigned>(wordMeasurement.startOffset));
                 DCHECK(m_current.offset() == static_cast<unsigned>(wordMeasurement.endOffset));
                 if (hyphenate(layoutText, style, font, *hyphenation, lastSpaceWordSpacing, wordMeasurement)) {
                     m_width.addUncommittedWidth(wordMeasurement.width);
                     hyphenated = true;
                     m_atEnd = true;
                     return false;
                 }
                 m_width.addUncommittedWidth(wordMeasurement.width);
             }
         }
 
+        // 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) {
+            float availableWidthBefore = m_width.availableWidth();
+            m_width.fitBelowFloats(m_lineInfo.isFirstLine());
+            // If availableWidth changes by moving the line below floats, needs to measure midWordBreak again.
+            if (midWordBreak && availableWidthBefore != m_width.availableWidth())
+                midWordBreak = false;
+        }

[kojii, 2016/07/05 11:37:58]

Doing this before rewindToMidWordBreak was the previous fix, but it was
incorrect. The new fix is to revert to do it after, but reset midWordBreak if
availableWidth was changed by floats, so that we loop again to recompute the new
break opportunity.

With this fix applied, word-break-all-wrap-with-floats.html fails without this
additional fix.

+
         // If there is a soft-break available at this whitespace position then take it.
         applyWordSpacing = wordSpacing && m_currentCharacterIsSpace;
         if (canBreakAtWhitespace(breakWords, wordMeasurement, stoppedIgnoringSpaces, charWidth, hyphenated, disableSoftHyphen, hyphenWidth, betweenWords, midWordBreak, canBreakMidWord, 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.getLineLayoutItem(), m_current.offset(), m_current.nextBreakablePosition());
@@ skipping 285 matching lines @@
 
     if (style.getTextIndentType() == TextIndentHanging)
         indentText = indentText == IndentText ? DoNotIndentText : IndentText;
 
     return indentText;
 }
 
 } // namespace blink
 
 #endif // BreakingContextInlineHeaders_h