Prevent to measure the whole word when break-word

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 642 matching lines @@
     }
 
     const ComputedStyle& style = layoutText.styleRef(m_lineInfo.isFirstLine());
     const Font& font = style.font();
 
     unsigned lastSpace = m_current.offset();
     float wordSpacing = m_currentStyle->wordSpacing();
     float lastSpaceWordSpacing = 0;
     float wordSpacingForWordMeasurement = 0;
 
+    float widthFromLastBreakingOpportunity = m_width.uncommittedWidth();
     float charWidth = 0;
     // Auto-wrapping text should wrap in the middle of a word only if it could not wrap before the word,
     // which is only possible if the word is the first thing on the line, that is, if |w| is zero.
     bool breakWords = m_currentStyle->breakWords() && ((m_autoWrap && !m_width.committedWidth()) || m_currWS == PRE);
+    bool midWordBreak = false;
     bool breakAll = m_currentStyle->wordBreak() == BreakAllWordBreak && m_autoWrap;
     bool keepAll = m_currentStyle->wordBreak() == KeepAllWordBreak && m_autoWrap;
     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;
 
@@ skipping 42 matching lines @@
             m_width.setTrailingWhitespaceWidth(0);
         }
 
         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 && !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();
+        }
+
         // 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));
         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) {
+        if (!betweenWords && !midWordBreak) {
             if (m_ignoringSpaces) {
                 // Stop ignoring spaces and begin at this
                 // new point.
                 lastSpaceWordSpacing = applyWordSpacing ? wordSpacing : 0;
                 wordSpacingForWordMeasurement = (applyWordSpacing && wordMeasurements.last().width) ? wordSpacing : 0;
                 stopIgnoringSpaces(lastSpace);
             }
 
             prepareForNextCharacter(layoutText, prohibitBreakInside, previousCharacterIsSpace);
             m_atStart = false;
@@ skipping 18 matching lines @@
             wordSpacingForWordMeasurement = 0;
             stoppedIgnoringSpaces = true;
             stopIgnoringSpaces(lastSpace);
         }
 
         // 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;
 
-        bool midWordBreak = false;
+        midWordBreak = false;
         if (canBreakMidWord && !m_width.fitsOnLine(lastWidthMeasurement)
             && rewindToMidWordBreak(layoutText, style, font, breakAll, wordMeasurement)) {
             lastWidthMeasurement = wordMeasurement.width;
             midWordBreak = true;
         }
 
         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.
@@ skipping 24 matching lines @@
             m_lineBreak.moveTo(m_current.getLineLayoutItem(), m_current.offset(), m_current.nextBreakablePosition());
             m_lineBreak.increment();
             m_lineInfo.setPreviousLineBrokeCleanly(true);
             return true;
         }
 
         // 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.getLineLayoutItem(), m_current.offset(), m_current.nextBreakablePosition());
             breakWords = false;
             canBreakMidWord = breakAll;
             widthMeasurementAtLastBreakOpportunity = lastWidthMeasurement;
         }
 
         if (betweenWords) {
             lastSpaceWordSpacing = applyWordSpacing ? wordSpacing : 0;
             wordSpacingForWordMeasurement = (applyWordSpacing && wordMeasurement.width) ? wordSpacing : 0;
             lastSpace = m_current.offset();
@@ skipping 20 matching lines @@
     m_layoutTextInfo.m_lineBreakIterator.setPriorContext(lastCharacter, secondToLastCharacter);
 
     wordMeasurements.grow(wordMeasurements.size() + 1);
     WordMeasurement& wordMeasurement = wordMeasurements.last();
     wordMeasurement.layoutText = layoutText;
 
     // IMPORTANT: current.offset() is > layoutText.textLength() here!
     float lastWidthMeasurement = 0;
     wordMeasurement.startOffset = lastSpace;
     wordMeasurement.endOffset = m_current.offset();
-    bool midWordBreak = false;
+    midWordBreak = false;
     if (!m_ignoringSpaces) {
         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);
 
         if (canBreakMidWord && !m_width.fitsOnLine(lastWidthMeasurement)
             && rewindToMidWordBreak(layoutText, style, font, breakAll, wordMeasurement)) {
             lastWidthMeasurement = wordMeasurement.width;
             midWordBreak = true;
         }
@@ skipping 211 matching lines @@
 
     if (style.getTextIndentType() == TextIndentHanging)
         indentText = indentText == IndentText ? DoNotIndentText : IndentText;
 
     return indentText;
 }
 
 } // namespace blink
 
 #endif // BreakingContextInlineHeaders_h