Fix min-content sizing for 'word-break: break-word'

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 980 matching lines @@
   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) {
+                                             int length,
+                                             EWordBreak breakAllOrBreakWord) {
   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;
+    int fragmentLength;
+    if (breakAllOrBreakWord == EWordBreak::BreakAllWordBreak) {
+      breakIterator.isBreakable(i + 1, nextBreakable, LineBreakType::BreakAll);
+      fragmentLength = (nextBreakable > i ? nextBreakable : length) - i;
+    } else {
+      fragmentLength = U16_LENGTH(layoutText->codepointAt(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;
@@ skipping 67 matching lines @@
   LazyLineBreakIterator breakIterator(m_text, styleToUse.locale());
   bool needsWordSpacing = false;
   bool ignoringSpaces = false;
   bool isSpace = false;
   bool firstWord = true;
   bool firstLine = true;
   int nextBreakable = -1;
   int lastWordBoundary = 0;
   float cachedWordTrailingSpaceWidth[2] = {0, 0};  // LTR, RTL
 
-  bool breakAll = (styleToUse.wordBreak() == BreakAllWordBreak ||
-                   styleToUse.wordBreak() == BreakWordBreak) &&
-                  styleToUse.autoWrap();
-  bool keepAll =
-      styleToUse.wordBreak() == KeepAllWordBreak && styleToUse.autoWrap();
+  EWordBreak breakAllOrBreakWord = EWordBreak::NormalWordBreak;
+  LineBreakType lineBreakType = LineBreakType::Normal;
+  if (styleToUse.autoWrap()) {
+    if (styleToUse.wordBreak() == BreakAllWordBreak ||
+        styleToUse.wordBreak() == BreakWordBreak) {
+      breakAllOrBreakWord = styleToUse.wordBreak();
+    } else if (styleToUse.wordBreak() == KeepAllWordBreak) {
+      lineBreakType = LineBreakType::KeepAll;
+    }
+  }
 
   Hyphenation* hyphenation =
       styleToUse.autoWrap() ? styleToUse.getHyphenation() : nullptr;
   bool disableSoftHyphen = styleToUse.getHyphens() == HyphensNone;
   float maxWordWidth = 0;
   if (!hyphenation)
     maxWordWidth = std::numeric_limits<float>::infinity();
 
   BidiResolver<TextRunIterator, BidiCharacterRun> bidiResolver;
   BidiCharacterRun* run;
@@ skipping 75 matching lines @@
       continue;
     }
     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,
-        keepAll ? LineBreakType::KeepAll : LineBreakType::Normal);
+    bool hasBreak = breakIterator.isBreakable(i, nextBreakable, lineBreakType);
     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) &&
@@ skipping 57 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;
         }
       }
 
-      if (breakAll) {
+      if (breakAllOrBreakWord != EWordBreak::NormalWordBreak) {
         // 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);
+        currMinWidth =
+            minWordFragmentWidthForBreakAll(this, styleToUse, f, textDirection,
+                                            i, wordLen, breakAllOrBreakWord);
       } else {
         currMinWidth += w;
       }
       if (betweenWords) {
         if (lastWordBoundary == i)
           currMaxWidth += w;
         else
           currMaxWidth += widthFromFont(
               f, lastWordBoundary, j - lastWordBoundary, leadWidth,
               currMaxWidth, textDirection, &fallbackFonts, &glyphBounds);
@@ skipping 716 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