Fix max preferred width for LayoutText when break-all

third_party/WebKit/Source/core/layout/LayoutText.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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
@@ skipping 949 matching lines @@
 
   return m_maxWidth;
 }
 
 void LayoutText::computePreferredLogicalWidths(float leadWidth) {
   HashSet<const SimpleFontData*> fallbackFonts;
   FloatRect glyphBounds;
   computePreferredLogicalWidths(leadWidth, fallbackFonts, glyphBounds);
 }
 
+static float minWordFragmentWidthForBreakAll(LayoutText* layoutText,
+                                             const ComputedStyle& style,
+                                             const Font& font,
+                                             TextDirection textDirection,
+                                             int start,
+                                             int length) {
+  DCHECK_GT(length, 0);
+  LazyLineBreakIterator breakIterator(layoutText->text(), style.locale());
+  int nextBreakable = -1;
+  float min = std::numeric_limits<float>::max();
+  int end = start + length;
+  for (int i = start; i < end;) {
+    breakIterator.isBreakable(i + 1, nextBreakable, LineBreakType::BreakAll);
+    int fragmentLength = (nextBreakable > i ? nextBreakable : length) - i;
+    // The correct behavior is to measure width without re-shaping, but we
+    // reshape each fragment here because a) the current line breaker does not
+    // support it, b) getCharacterRange() can reshape if the text is too long
+    // to fit in the cache, and c) each fragment here is almost 1 char and thus
+    // reshape is fast.
+    TextRun run = constructTextRun(font, layoutText, i, fragmentLength, style,
+                                   textDirection);
+    float fragmentWidth = font.width(run);
+    min = std::min(min, fragmentWidth);
+    i += fragmentLength;
+  }
+  return min;
+}
+
 static float maxWordFragmentWidth(LayoutText* layoutText,
                                   const ComputedStyle& style,
                                   const Font& font,
                                   TextDirection textDirection,
                                   Hyphenation& hyphenation,
                                   unsigned wordOffset,
                                   unsigned wordLength,
                                   int& suffixStart) {
   suffixStart = 0;
   if (wordLength <= Hyphenation::minimumSuffixLength)
@@ skipping 154 matching lines @@
     if (c == softHyphenCharacter && !disableSoftHyphen) {
       currMaxWidth += widthFromFont(f, lastWordBoundary, i - lastWordBoundary,
                                     leadWidth, currMaxWidth, textDirection,
                                     &fallbackFonts, &glyphBounds);
       lastWordBoundary = i + 1;
       continue;
     }
 
     bool hasBreak = breakIterator.isBreakable(
         i, nextBreakable,
-        breakAll ? LineBreakType::BreakAll
-                 : keepAll ? LineBreakType::KeepAll : LineBreakType::Normal);
+        keepAll ? LineBreakType::KeepAll : LineBreakType::Normal);
     bool betweenWords = true;
     int j = i;
     while (c != newlineCharacter && c != spaceCharacter &&
            c != tabulationCharacter &&
            (c != softHyphenCharacter || disableSoftHyphen)) {
       j++;
       if (j == len)
         break;
       c = uncheckedCharacterAt(j);
       if (breakIterator.isBreakable(j, nextBreakable) &&
           characterAt(j - 1) != softHyphenCharacter)
         break;
-      if (breakAll) {
-        betweenWords = false;
-        break;
-      }
     }
 
     // Terminate word boundary at bidi run boundary.
     if (run)
       j = std::min(j, run->stop() + 1);
     int wordLen = j - i;
     if (wordLen) {
       bool isSpace = (j < len) && c == spaceCharacter;
 
       // Non-zero only when kerning is enabled, in which case we measure words
@@ skipping 41 matching lines @@
                 f, i + suffixStart, wordLen - suffixStart, leadWidth,
                 currMaxWidth, textDirection, &fallbackFonts, &glyphBounds);
           maxFragmentWidth = std::max(maxFragmentWidth, suffixWidth);
           currMinWidth += maxFragmentWidth - w;
           maxWordWidth = std::max(maxWordWidth, maxFragmentWidth);
         } else {
           maxWordWidth = w;
         }
       }
 
-      currMinWidth += w;
+      if (breakAll) {
+        // Because sum of character widths may not be equal to the word width,
+        // we need to measure twice; once with normal break for max width,
+        // another with break-all for min width.
+        currMinWidth = minWordFragmentWidthForBreakAll(
+            this, styleToUse, f, textDirection, i, wordLen);
+      } else {
+        currMinWidth += w;
+      }
       if (betweenWords) {
         if (lastWordBoundary == i)
           currMaxWidth += w;
         else
           currMaxWidth += widthFromFont(
               f, lastWordBoundary, j - lastWordBoundary, leadWidth,
               currMaxWidth, textDirection, &fallbackFonts, &glyphBounds);
         lastWordBoundary = j;
       }
 
@@ skipping 718 matching lines @@
   LayoutRect rect = LayoutRect(
       IntRect(firstRunX(), firstRunY(), linesBox.width(), linesBox.height()));
   LayoutBlock* block = containingBlock();
   if (block && hasTextBoxes())
     block->adjustChildDebugRect(rect);
 
   return rect;
 }
 
 }  // namespace blink