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/fonts/CharacterRange.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()
+        - 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.
+    // These are heuristic numbers for performance added in http://wkb.ug/45606 .
+    const int minPrefixWidthNumerator = 5;
+    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;
+
+    CharacterRange range = font.getCharacterRange(run, 0, prefixLength);
+    return rewindToMidWordBreak(wordMeasurement, start + prefixLength, range.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