Implement "word-break: keep-all" in CSS3 Text

Source/platform/text/TextBreakIterator.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2007-2009 Torch Mobile, Inc.
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * 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 207 matching lines @@
                 return i > pos && U16_IS_TRAIL(ch) ? i - 1 : i;
             lastIsLetterOrNumber = isLetterOrNumber;
         }
 
         lastLastCh = lastCh;
         lastCh = ch;
     }
     return len;
 }
 
+static inline bool shouldKeepAfter(UChar lastCh, UChar ch, UChar nextCh)
+{
+    UChar preCh = U_MASK(u_charType(ch)) & U_GC_M_MASK ? lastCh : ch;
+    return U_MASK(u_charType(preCh)) & (U_GC_L_MASK | U_GC_N_MASK)
+        && !WTF::Unicode::hasLineBreakingPropertyComplexContext(preCh)
+        && U_MASK(u_charType(nextCh)) & (U_GC_L_MASK | U_GC_N_MASK)
+        && !WTF::Unicode::hasLineBreakingPropertyComplexContext(nextCh);
+}
+
+static inline int nextBreakablePositionKeepAllInternal(LazyLineBreakIterator& lazyBreakIterator, const UChar* str, unsigned length, int pos)
+{
+    int len = static_cast<int>(length);
+    int nextBreak = -1;
+
+    UChar lastLastCh = pos > 1 ? str[pos - 2] : static_cast<UChar>(lazyBreakIterator.secondToLastCharacter());
+    UChar lastCh = pos > 0 ? str[pos - 1] : static_cast<UChar>(lazyBreakIterator.lastCharacter());
+    unsigned priorContextLength = lazyBreakIterator.priorContextLength();
+    for (int i = pos; i < len; i++) {
+        UChar ch = str[i];
+
+        if (isBreakableSpace(ch) || shouldBreakAfter(lastLastCh, lastCh, ch))
+            return i;
+
+        if (!shouldKeepAfter(lastLastCh, lastCh, ch) && (needsLineBreakIterator(ch) || needsLineBreakIterator(lastCh))) {
+            if (nextBreak < i) {
+                // Don't break if positioned at start of primary context and there is no prior context.
+                if (i || priorContextLength) {
+                    TextBreakIterator* breakIterator = lazyBreakIterator.get(priorContextLength);
+                    if (breakIterator) {
+                        nextBreak = breakIterator->following(i - 1 + priorContextLength);
+                        if (nextBreak >= 0) {
+                            nextBreak -= priorContextLength;
+                        }
+                    }
+                }
+            }
+            if (i == nextBreak && !isBreakableSpace(lastCh))
+                return i;
+        }
+
+        lastLastCh = lastCh;
+        lastCh = ch;
+    }
+
+    return len;
+}
+
 int LazyLineBreakIterator::nextBreakablePositionIgnoringNBSP(int pos)
 {
     if (m_string.is8Bit())
         return nextBreakablePosition<LChar>(*this, m_string.characters8(), m_string.length(), pos);
     return nextBreakablePosition<UChar>(*this, m_string.characters16(), m_string.length(), pos);
 }
 
 int LazyLineBreakIterator::nextBreakablePositionBreakAll(int pos)
 {
     if (m_string.is8Bit())
         return nextBreakablePositionBreakAllInternal<LChar>(*this, m_string.characters8(), m_string.length(), pos);
     return nextBreakablePositionBreakAllInternal<UChar>(*this, m_string.characters16(), m_string.length(), pos);
 }
 
+int LazyLineBreakIterator::nextBreakablePositionKeepAll(int pos)
+{
+    if (m_string.is8Bit())
+        return nextBreakablePosition<LChar>(*this, m_string.characters8(), m_string.length(), pos);
+    return nextBreakablePositionKeepAllInternal(*this, m_string.characters16(), m_string.length(), pos);
+}
 
 } // namespace blink