Fix emoji ZWJ and modifier sequence line breaking

third_party/WebKit/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.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "platform/text/TextBreakIterator.h"
 
+#include "platform/fonts/Character.h"
 #include "wtf/ASCIICType.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/CharacterNames.h"
 
 namespace blink {
 
 unsigned numGraphemeClusters(const String& string)
 {
     unsigned stringLength = string.length();
 
@@ skipping 179 matching lines @@
         return tableRow[lineBreak / 8] & (1 << (lineBreak % 8));
     }
     return false;
 }
 
 inline bool needsLineBreakIterator(UChar ch)
 {
     return ch > asciiLineBreakTableLastChar && ch != noBreakSpaceCharacter;
 }
 
+// Customization for ICU line breaking behavior. This allows us to reject ICU
+// line break suggestions which would split an emoji sequence.
+// FIXME crbug.com/593260: Remove this customization once ICU implements this
+// natively.
+static bool isBreakValid(const UChar* buf, size_t length, size_t breakPos)
+{
+    UChar32 codepoint;
+    size_t prevOffset = breakPos;
+    U16_PREV(buf, 0, prevOffset, codepoint);
+    uint32_t nextCodepoint;
+    size_t nextOffset = breakPos;
+    U16_NEXT(buf, nextOffset, length, nextCodepoint);
+
+    // Possible Emoji ZWJ sequence
+    if (codepoint == zeroWidthJoinerCharacter) {
+        if (nextCodepoint == 0x2764 // HEAVY BLACK HEART
+            || nextCodepoint == 0x1F466 // BOY
+            || nextCodepoint == 0x1F467 // GIRL
+            || nextCodepoint == 0x1F468 // MAN
+            || nextCodepoint == 0x1F469 // WOMAN
+            || nextCodepoint == 0x1F48B // KISS MARK
+            || nextCodepoint == 0x1F5E8) // LEFT SPEECH BUBBLE
+        {
+            return false;
+        }
+    }
+
+    // Possible emoji modifier sequence
+    // Proposed Rule LB30b from http://www.unicode.org/L2/L2016/16011r3-break-prop-emoji.pdf
+    // EB x EM
+    if (Character::isModifier(nextCodepoint)) {
+        if (codepoint == variationSelector16Character && prevOffset > 0) {
+            // Skip over emoji variation selector.
+            U16_PREV(buf, 0, prevOffset, codepoint);
+        }
+        if (Character::isEmojiModifierBase(codepoint)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+// Trivial implementation to match possible template paramters in
+// nextBreakablePosition. There are no emoji sequences in 8bit strings, so we
+// accept all break opportunities.
+static bool isBreakValid(const LChar*, size_t, size_t)
+{
+    return true;
+}
+
 template<typename CharacterType, LineBreakType lineBreakType>
 static inline int nextBreakablePosition(LazyLineBreakIterator& lazyBreakIterator, const CharacterType* str, unsigned length, int pos)
 {
     int len = static_cast<int>(length);
     int nextBreak = -1;
 
     CharacterType lastLastCh = pos > 1 ? str[pos - 2] : static_cast<CharacterType>(lazyBreakIterator.secondToLastCharacter());
     CharacterType lastCh = pos > 0 ? str[pos - 1] : static_cast<CharacterType>(lazyBreakIterator.lastCharacter());
     ULineBreak lastLineBreak;
     if (lineBreakType == LineBreakType::BreakAll)
@@ skipping 19 matching lines @@
                 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))
+            if (i == nextBreak && !isBreakableSpace(lastCh) && isBreakValid(str, length, i)) {
                 return i;
+            }
         }
 
         lastLastCh = lastCh;
         lastCh = ch;
     }
 
     return len;
 }
 
 static inline bool shouldKeepAfter(UChar lastCh, UChar ch, UChar nextCh)
@@ skipping 25 matching lines @@
                 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))
+            if (i == nextBreak && !isBreakableSpace(lastCh) && isBreakValid(str, length, i))
                 return i;
         }
 
         lastLastCh = lastCh;
         lastCh = ch;
     }
 
     return len;
 }
 
@@ skipping 16 matching lines @@
 }
 
 int LazyLineBreakIterator::nextBreakablePositionKeepAll(int pos)
 {
     if (m_string.is8Bit())
         return nextBreakablePosition<LChar, LineBreakType::Normal>(*this, m_string.characters8(), m_string.length(), pos);
     return nextBreakablePositionKeepAllInternal(*this, m_string.characters16(), m_string.length(), pos);
 }
 
 } // namespace blink