Enable hyphens: auto and none in BreakingContext

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 22 matching lines @@
 #include "core/layout/api/LineLayoutTextCombine.h"
 #include "core/layout/line/InlineIterator.h"
 #include "core/layout/line/InlineTextBox.h"
 #include "core/layout/line/LayoutTextInfo.h"
 #include "core/layout/line/LineBreaker.h"
 #include "core/layout/line/LineInfo.h"
 #include "core/layout/line/LineWidth.h"
 #include "core/layout/line/TrailingObjects.h"
 #include "core/layout/line/WordMeasurement.h"
 #include "core/paint/PaintLayer.h"
+#include "platform/text/Hyphenation.h"
 #include "platform/text/TextBreakIterator.h"
 #include "wtf/Allocator.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 // We don't let our line box tree for a single line get any deeper than this.
 const unsigned cMaxLineDepth = 200;
 
 class BreakingContext {
@@ skipping 39 matching lines @@
 
     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 canBreakAtWhitespace(bool breakWords, WordMeasurement&, bool stoppedIgnoringSpaces, bool& hyphenated, float charWidth, float& hyphenWidth, bool betweenWords, bool midWordBreak, bool canBreakMidWord, bool previousCharacterIsSpace, float lastWidthMeasurement, const LineLayoutText&, const Font&, bool applyWordSpacing, float wordSpacing);
+    bool canBreakAtWhitespace(bool breakWords, WordMeasurement&, bool stoppedIgnoringSpaces, float charWidth, bool& hyphenated, bool disableSoftHyphen, float& hyphenWidth, bool betweenWords, bool midWordBreak, bool canBreakMidWord, bool previousCharacterIsSpace, float lastWidthMeasurement, const LineLayoutText&, const Font&, bool applyWordSpacing, float wordSpacing);
     bool trailingSpaceExceedsAvailableWidth(bool canBreakMidWord, const LineLayoutText&, WordMeasurement&, bool applyWordSpacing, bool wordSpacing, const Font&);
     WordMeasurement& calculateWordWidth(WordMeasurements&, LineLayoutText&, unsigned 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:
     void skipTrailingWhitespace(InlineIterator&, const LineInfo&);
     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;
 
     LineLayoutBlockFlow m_block;
     LineLayoutItem m_lastObject;
     LineLayoutItem m_nextObject;
@@ skipping 423 matching lines @@
         lastBreakablePosition = nextBreakablePosition;
     }
 }
 
 ALWAYS_INLINE bool BreakingContext::rewindToMidWordBreak(
     WordMeasurement& wordMeasurement, int end, float width)
 {
     wordMeasurement.endOffset = end;
     wordMeasurement.width = width;
 
-    m_current.moveTo(m_current.getLineLayoutItem(), end);
-    m_lineBreak.moveTo(m_current.getLineLayoutItem(), m_current.offset());
+    m_current.moveTo(m_current.getLineLayoutItem(), end, m_current.nextBreakablePosition());
+    m_lineBreak.moveTo(m_current.getLineLayoutItem(), end, m_current.nextBreakablePosition());
     return true;
 }
 
 ALWAYS_INLINE bool BreakingContext::rewindToFirstMidWordBreak(LineLayoutText text,
     const ComputedStyle& style, const Font& font, bool breakAll,
     WordMeasurement& wordMeasurement)
 {
     int start = wordMeasurement.startOffset;
     int end;
     if (breakAll) {
@@ skipping 40 matching lines @@
         end = lastBreakablePositionForBreakAll(text, style, start, end);
         if (!end)
             return false;
         len = end - start;
     }
     FloatRect rect = font.selectionRectForText(run, FloatPoint(), 0, 0, len);
     DCHECK(m_width.fitsOnLine(rect.width() - 1)); // avoid failure when rect is rounded up.
     return rewindToMidWordBreak(wordMeasurement, end, rect.width());
 }
 
+ALWAYS_INLINE bool BreakingContext::hyphenate(LineLayoutText text,
+    const ComputedStyle& style, const Font& font,
+    const Hyphenation& hyphenation, float lastSpaceWordSpacing,
+    WordMeasurement& wordMeasurement)
+{
+    const unsigned minimumPrefixLength = 2;
+    const unsigned minimumSuffixLength = 2;
+    unsigned start = wordMeasurement.startOffset;
+    unsigned len = wordMeasurement.endOffset - start;
+    if (len <= minimumSuffixLength)
+        return false;
+
+    float hyphenWidth = text.hyphenWidth(font, textDirectionFromUnicode(m_resolver.position().direction()));
+    float maxPrefixWidth = m_width.availableWidth() + LayoutUnit::epsilon()

[eae, 2016/05/16 16:43:26]

Do we need epsilon here? If we can ceil a floor to layout unit instead
LayoutUnit::fromFloatCeil that might allow us to not have to add epsilon.

[kojii, 2016/05/16 17:29:34]

When tests use ch/em that should exactly fit, this is needed. And also this is
aligned with LineWidth::fitsOnLine() adds epsilon. In break-all, without
epsilon, we can fit slightly less in existing tests.

But from the test in this CL, it doesn't fit when it's "3ch" (so the test has
"3.1ch"), and this is a new code path, so this can be removed if I adjust tests
to have slight buffer for other widths too. PS7 removes epsilon without
modifying tests, will add ".1ch" to tests if any fail.

[eae, 2016/05/16 17:32:38]

Thanks. We're trying to remove epsilon from LineWidth::fitsOnLine.

+        - m_width.currentWidth() - hyphenWidth - lastSpaceWordSpacing;
+
+    // If the maximum width available for the prefix before the hyphen is small, then it is very unlikely
+    // that an hyphenation opportunity exists, so do not bother to look for it.
+    const int minPrefixWidthNumerator = 5;

[eae, 2016/05/16 16:43:25]

Where did you get these numbers from?

[kojii, 2016/05/16 17:29:34]

From our removal patch (crrev.com/20526006). ToT WebKit has the same number.

[eae, 2016/05/16 17:32:38]

Ok, could you add a quick comment explaining the numbers?

+    const int minPrefixWidthDenominator = 4;
+    if (maxPrefixWidth <= font.getFontDescription().computedSize() * minPrefixWidthNumerator / minPrefixWidthDenominator)
+        return false;
+
+    TextRun run = constructTextRun(font, text, start, len, style);
+    run.setTabSize(!m_collapseWhiteSpace, style.getTabSize());
+    run.setXPos(m_width.currentWidth());
+    unsigned maxPrefixLength = font.offsetForPosition(run, maxPrefixWidth, false);
+    if (maxPrefixLength < minimumPrefixLength)
+        return false;
+
+    unsigned prefixLength = hyphenation.lastHyphenLocation(
+        text.text().createView(start, len),
+        std::min(maxPrefixLength, len - minimumSuffixLength) + 1);
+    if (!prefixLength || prefixLength < minimumPrefixLength)
+        return false;
+
+    FloatRect rect = font.selectionRectForText(run, FloatPoint(), 0, 0, prefixLength);

[eae, 2016/05/16 16:43:25]

Calling shaper.getCharacterRange instead of selection rect would be better as
that gives access to the actual character positions and doesn't do the snapping
or height adjustments.

[kojii, 2016/05/16 17:29:34]

Done.

[eae, 2016/05/16 17:32:38]

Thanks!`

+    return rewindToMidWordBreak(wordMeasurement, start + prefixLength, rect.width());
+}
+
 inline bool BreakingContext::handleText(WordMeasurements& wordMeasurements, bool& hyphenated)
 {
     if (!m_current.offset())
         m_appliedStartWidth = false;
 
     LineLayoutText layoutText(m_current.getLineLayoutItem());
 
     // 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) {
@@ skipping 18 matching lines @@
     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;
 
+    Hyphenation* hyphenation = style.getHyphens() == HyphensAuto
+        ? Hyphenation::get(font.getFontDescription().locale()) : nullptr;
+    bool disableSoftHyphen = style.getHyphens() == HyphensNone;
     float hyphenWidth = 0;
 
     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.
@@ skipping 25 matching lines @@
     for (; m_current.offset() < layoutText.textLength(); m_current.fastIncrementInTextNode()) {
         bool previousCharacterIsSpace = m_currentCharacterIsSpace;
         UChar c = m_current.current();
         m_currentCharacterIsSpace = c == spaceCharacter || c == tabulationCharacter || (!m_preservesNewline && (c == newlineCharacter));
 
         if (!m_collapseWhiteSpace || !m_currentCharacterIsSpace) {
             m_lineInfo.setEmpty(false);
             m_width.setTrailingWhitespaceWidth(0);
         }
 
-        if (c == softHyphenCharacter && m_autoWrap && !hyphenWidth) {
+        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();
         }
 
         // 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));
+        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) {
                 // Stop ignoring spaces and begin at this
                 // new point.
                 lastSpaceWordSpacing = applyWordSpacing ? wordSpacing : 0;
                 wordSpacingForWordMeasurement = (applyWordSpacing && wordMeasurements.last().width) ? wordSpacing : 0;
                 stopIgnoringSpaces(lastSpace);
@@ skipping 41 matching lines @@
         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 (canBreakMidWord && !m_width.fitsOnLine()) {
-            m_width.addUncommittedWidth(-wordMeasurement.width);
-            if (rewindToMidWordBreak(layoutText, style, font, breakAll, wordMeasurement)) {
-                lastWidthMeasurement = wordMeasurement.width + lastSpaceWordSpacing;
-                midWordBreak = true;
+        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);
             }
-            m_width.addUncommittedWidth(wordMeasurement.width);
         }
 
         // 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, canBreakMidWord, previousCharacterIsSpace, lastWidthMeasurement, layoutText, font, applyWordSpacing, wordSpacing))
+        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());
             m_lineBreak.increment();
             m_lineInfo.setPreviousLineBrokeCleanly(true);
             return true;
@@ skipping 62 matching lines @@
     m_width.addUncommittedWidth(lastWidthMeasurement + additionalWidthFromAncestors);
 
     if (m_collapseWhiteSpace && m_currentCharacterIsSpace && lastWidthMeasurement)
         m_width.setTrailingWhitespaceWidth(lastWidthMeasurement + additionalWidthFromAncestors);
 
     m_includeEndWidth = false;
 
     if (midWordBreak) {
         m_width.commit();
         m_atEnd = true;
-    } else if (!m_width.fitsOnLine() && !hyphenated
-        && m_lineBreak.previousInSameNode() == softHyphenCharacter) {
-        hyphenated = true;
-        m_atEnd = true;
+    } else if (!m_width.fitsOnLine()) {
+        if (hyphenation && (m_nextObject || m_lineInfo.isEmpty())) {
+            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)) {
+                hyphenated = true;
+                m_atEnd = true;
+            }
+            m_width.addUncommittedWidth(wordMeasurement.width);
+        }
+        if (!hyphenated
+            && m_lineBreak.previousInSameNode() == softHyphenCharacter
+            && !disableSoftHyphen) {
+            hyphenated = true;
+            m_atEnd = true;
+        }
     }
     return false;
 }
 
 inline void BreakingContext::prepareForNextCharacter(const LineLayoutText& layoutText, bool& prohibitBreakInside, bool previousCharacterIsSpace)
 {
     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);
@@ skipping 55 matching lines @@
         // additional whitespace.
         if (!m_width.fitsOnLine(charWidth)) {
             m_lineBreak.moveTo(m_current.getLineLayoutItem(), 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 canBreakMidWord, bool previousCharacterIsSpace, float lastWidthMeasurement, const LineLayoutText& layoutText, const Font& font, bool applyWordSpacing, float wordSpacing)
+inline bool BreakingContext::canBreakAtWhitespace(bool breakWords, WordMeasurement& wordMeasurement, bool stoppedIgnoringSpaces, float charWidth, bool& hyphenated, bool disableSoftHyphen, float& hyphenWidth, bool betweenWords, bool midWordBreak, bool canBreakMidWord, 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 (midWordBreak
         || trailingSpaceExceedsAvailableWidth(canBreakMidWord, 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.getLineLayoutItem() && m_lineBreak.offset() && m_lineBreak.getLineLayoutItem().isText() && LineLayoutText(m_lineBreak.getLineLayoutItem()).textLength() && LineLayoutText(m_lineBreak.getLineLayoutItem()).characterAt(m_lineBreak.offset() - 1) == softHyphenCharacter)
+        if (m_lineBreak.getLineLayoutItem() && m_lineBreak.offset() && m_lineBreak.getLineLayoutItem().isText() && LineLayoutText(m_lineBreak.getLineLayoutItem()).textLength() && LineLayoutText(m_lineBreak.getLineLayoutItem()).characterAt(m_lineBreak.offset() - 1) == softHyphenCharacter && !disableSoftHyphen)
             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;
@@ skipping 90 matching lines @@
 
     if (style.getTextIndentType() == TextIndentHanging)
         indentText = indentText == IndentText ? DoNotIndentText : IndentText;
 
     return indentText;
 }
 
 } // namespace blink
 
 #endif // BreakingContextInlineHeaders_h