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 isComplexContextDependent(UChar ch)

[jungshik at Google, 2015/04/23 20:34:15]

Please, use  either requiresContextForWordBoundary(UChar32 ch) in 
TextBoundaries.h or WTF::Unicode::hasLineBreakingPropertyComplexContext()
instead of enumerating blocks here (that will get obsolete as the standard moves
on). 

Moreover, you have to use UChar32. 
See nextBreakablePositionBreakAllInternal() and
isUnicodeCategoryLetterOrNumber() above and do something similar to  handle 
non-BMP characters (represented in a pair of UChar's - surrogate pairs in
UTF-16) in nextBreakablePositionKeepAllInternal(). 

There are about 2,200 relatively widely used CJK ideographs in Plane 2 (about
2,000 from Hong Kong and about 200 from JIS X 213) and you can add them (need
not be them, though ) to layout tests

[yunsik, 2015/04/24 07:01:15]

Yes you're right. they seem to be better to use. I didn't see that such a
function is already existing. Thanks for your advice.
Because ICU does not break between surrogates (not only between surrogate
pairs), there would be no breaking opportunity between non-BMP characters. It is
same even in case of word-break: normal.

So, I don't think i should do something for surrogates. 
Build bot mac_blink_rel fails in layout tests with weird letter space problem
which I cannot reproduce with my mac. So I'm afraid to add many case of letters
into layout test ;(

+{
+    switch (ublock_getCode(ch)) {
+    case UBLOCK_THAI:
+    case UBLOCK_LAO:
+    case UBLOCK_MYANMAR:
+    case UBLOCK_KHMER:
+    case UBLOCK_TAI_LE:
+    case UBLOCK_NEW_TAI_LUE:
+    case UBLOCK_TAI_THAM:
+    case UBLOCK_MYANMAR_EXTENDED_A:
+    case UBLOCK_TAI_VIET:
+        return true;
+    default:
+        return false;
+    }
+}
+
+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)
+        && !isComplexContextDependent(preCh)
+        && U_MASK(u_charType(nextCh)) & (U_GC_L_MASK | U_GC_N_MASK)
+        && !isComplexContextDependent(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