TextBreakIterator should use the C++ icu API instead of the C one

Source/core/platform/text/TextBreakIteratorICU.cpp

 /*
  * Copyright (C) 2006 Lars Knoll <lars@trolltech.com>
  * Copyright (C) 2007, 2011, 2012 Apple 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,
@@ skipping 13 matching lines @@
 
 #include "core/platform/text/LineBreakIteratorPoolICU.h"
 #include "wtf/ThreadingPrimitives.h"
 #include "wtf/text/WTFString.h"
 
 using namespace WTF;
 using namespace std;
 
 namespace WebCore {
 
-static TextBreakIterator* ensureIterator(bool& createdIterator, TextBreakIterator*& iterator, UBreakIteratorType type)
-{
-    if (!createdIterator) {
-        UErrorCode openStatus = U_ZERO_ERROR;
-        iterator = reinterpret_cast<TextBreakIterator*>(ubrk_open(type, currentTextBreakLocaleID(), 0, 0, &openStatus));
-        createdIterator = true;
-        ASSERT_WITH_MESSAGE(U_SUCCESS(openStatus), "ICU could not open a break iterator: %s (%d)", u_errorName(openStatus), openStatus);
-    }
-    return iterator;
-}
-
 enum TextContext { NoContext, PriorContext, PrimaryContext };
 
 const int textBufferCapacity = 16;
 
 typedef struct {
     UText text;
     UChar buffer[textBufferCapacity];
 } UTextWithBuffer;
 
 static inline int64_t textPinIndex(int64_t& index, int64_t limit)
@@ skipping 348 matching lines @@
     if (U_FAILURE(*status)) {
         ASSERT(!text);
         return 0;
     }
     textInit(text, &textUTF16Funcs, string, length, priorContext, priorContextLength);
     return text;
 }
 
 static UText emptyText = UTEXT_INITIALIZER;
 
-static TextBreakIterator* setUpIterator(bool& createdIterator, TextBreakIterator*& iterator, UBreakIteratorType type, const UChar* string, int length)
+static TextBreakIterator* wordBreakIterator(const LChar* string, int length)
 {
-    if (!string)
-        return 0;
-
-    iterator = ensureIterator(createdIterator, iterator, type);
-    if (!iterator)
-        return 0;
-
-    UErrorCode setTextStatus = U_ZERO_ERROR;
-    ubrk_setText(reinterpret_cast<UBreakIterator*>(iterator), string, length, &setTextStatus);
-    if (U_FAILURE(setTextStatus))
-        return 0;
-
-    return iterator;
-}
-
-static TextBreakIterator* setUpIterator(bool& createdIterator, TextBreakIterator*& iterator, UBreakIteratorType type, const LChar* string, int length)
-{
-    if (!string)
-        return 0;
-
-    iterator = ensureIterator(createdIterator, iterator, type);
-    if (!iterator)
-        return 0;
+    UErrorCode errorCode = U_ZERO_ERROR;
+    static TextBreakIterator* breakIter = 0;
+    if (!breakIter) {
+        breakIter = icu::BreakIterator::createWordInstance(currentTextBreakLocaleID(), errorCode);
+        ASSERT_WITH_MESSAGE(U_SUCCESS(errorCode), "ICU could not open a break iterator: %s (%d)", u_errorName(errorCode), errorCode);
+        if (!breakIter)
+            return 0;
+    }
 
     UTextWithBuffer textLocal;
     textLocal.text = emptyText;
     textLocal.text.extraSize = sizeof(textLocal.buffer);
     textLocal.text.pExtra = textLocal.buffer;
 
     UErrorCode openStatus = U_ZERO_ERROR;
     UText* text = textOpenLatin1(&textLocal, string, length, 0, 0, &openStatus);
     if (U_FAILURE(openStatus)) {
         LOG_ERROR("textOpenLatin1 failed with status %d", openStatus);
         return 0;
     }
 
     UErrorCode setTextStatus = U_ZERO_ERROR;
-    ubrk_setUText(reinterpret_cast<UBreakIterator*>(iterator), text, &setTextStatus);
+    breakIter->setText(text, setTextStatus);
     if (U_FAILURE(setTextStatus)) {
         LOG_ERROR("ubrk_setUText failed with status %d", setTextStatus);
-        // FIXME: Do we need to call utext_close(text) here?
-        return 0;
+        delete breakIter;
     }
 
     utext_close(text);
 
-    return iterator;
-}
-
-static TextBreakIterator* wordBreakIterator(const LChar* string, int length)
-{
-    static bool createdWordBreakIterator8 = false;
-    static TextBreakIterator* staticWordBreakIterator8;
-    return setUpIterator(createdWordBreakIterator8,
-        staticWordBreakIterator8, UBRK_WORD, string, length);
+    return breakIter;
 }
 
 TextBreakIterator* wordBreakIterator(const UChar* string, int length)
 {
-    static bool createdWordBreakIterator16 = false;
-    static TextBreakIterator* staticWordBreakIterator16;
-    return setUpIterator(createdWordBreakIterator16,
-        staticWordBreakIterator16, UBRK_WORD, string, length);
+    UErrorCode errorCode = U_ZERO_ERROR;
+    static TextBreakIterator* breakIter = 0;
+    if (!breakIter) {
+        breakIter = icu::BreakIterator::createWordInstance(currentTextBreakLocaleID(), errorCode);
+        ASSERT_WITH_MESSAGE(U_SUCCESS(errorCode), "ICU could not open a break iterator: %s (%d)", u_errorName(errorCode), errorCode);
+        if (!breakIter)
+            return 0;
+    }
+
+    breakIter->setText(icu::UnicodeString(string, length));
+    return breakIter;
 }
 
 TextBreakIterator* wordBreakIterator(const String& string, int start, int length)
 {
     if (string.isEmpty())
         return 0;
     if (string.is8Bit())
         return wordBreakIterator(string.characters8() + start, length);
     return wordBreakIterator(string.characters16() + start, length);
 }
 
 TextBreakIterator* acquireLineBreakIterator(const LChar* string, int length, const AtomicString& locale, const UChar* priorContext, unsigned priorContextLength)
 {
-    UBreakIterator* iterator = LineBreakIteratorPool::sharedPool().take(locale);
+    TextBreakIterator* iterator = LineBreakIteratorPool::sharedPool().take(locale);
     if (!iterator)
         return 0;
 
     UTextWithBuffer textLocal;
     textLocal.text = emptyText;
     textLocal.text.extraSize = sizeof(textLocal.buffer);
     textLocal.text.pExtra = textLocal.buffer;
 
     UErrorCode openStatus = U_ZERO_ERROR;
     UText* text = textOpenLatin1(&textLocal, string, length, priorContext, priorContextLength, &openStatus);
     if (U_FAILURE(openStatus)) {
         LOG_ERROR("textOpenLatin1 failed with status %d", openStatus);
         return 0;
     }
 
     UErrorCode setTextStatus = U_ZERO_ERROR;
-    ubrk_setUText(iterator, text, &setTextStatus);
+    iterator->setText(text, setTextStatus);
     if (U_FAILURE(setTextStatus)) {
-        // FIXME: Do we need to call utext_close(text) here?
         LOG_ERROR("ubrk_setUText failed with status %d", setTextStatus);
         return 0;
     }
 
     utext_close(text);
 
-    return reinterpret_cast<TextBreakIterator*>(iterator);
+    return iterator;
 }
 
 TextBreakIterator* acquireLineBreakIterator(const UChar* string, int length, const AtomicString& locale, const UChar* priorContext, unsigned priorContextLength)
 {
-    UBreakIterator* iterator = LineBreakIteratorPool::sharedPool().take(locale);
+    TextBreakIterator* iterator = LineBreakIteratorPool::sharedPool().take(locale);
     if (!iterator)
         return 0;
 
     UText textLocal = UTEXT_INITIALIZER;
 
     UErrorCode openStatus = U_ZERO_ERROR;
     UText* text = textOpenUTF16(&textLocal, string, length, priorContext, priorContextLength, &openStatus);
     if (U_FAILURE(openStatus)) {
         LOG_ERROR("textOpenUTF16 failed with status %d", openStatus);
         return 0;
     }
 
     UErrorCode setTextStatus = U_ZERO_ERROR;
-    ubrk_setUText(iterator, text, &setTextStatus);
+    iterator->setText(text, setTextStatus);
     if (U_FAILURE(setTextStatus)) {
-        // FIXME: Do we need to call utext_close(text) here?
         LOG_ERROR("ubrk_setUText failed with status %d", setTextStatus);
         return 0;
     }
 
     utext_close(text);
 
-    return reinterpret_cast<TextBreakIterator*>(iterator);
+    return iterator;
 }
 
 void releaseLineBreakIterator(TextBreakIterator* iterator)
 {
     ASSERT_ARG(iterator, iterator);
 
-    LineBreakIteratorPool::sharedPool().put(reinterpret_cast<UBreakIterator*>(iterator));
+    LineBreakIteratorPool::sharedPool().put(iterator);
 }
 
 static TextBreakIterator* nonSharedCharacterBreakIterator;
 
 static inline bool compareAndSwapNonSharedCharacterBreakIterator(TextBreakIterator* expected, TextBreakIterator* newValue)
 {
     DEFINE_STATIC_LOCAL(Mutex, nonSharedCharacterBreakIteratorMutex, ());
     MutexLocker locker(nonSharedCharacterBreakIteratorMutex);
     if (nonSharedCharacterBreakIterator != expected)
         return false;
@@ skipping 30 matching lines @@
     , m_length(0)
     , m_iterator(0)
 {
     createIteratorForBuffer(buffer, length);
 }
 
 void NonSharedCharacterBreakIterator::createIteratorForBuffer(const UChar* buffer, unsigned length)
 {
     m_iterator = nonSharedCharacterBreakIterator;
     bool createdIterator = m_iterator && compareAndSwapNonSharedCharacterBreakIterator(m_iterator, 0);
-    m_iterator = setUpIterator(createdIterator, m_iterator, UBRK_CHARACTER, buffer, length);
+    if (!createdIterator) {
+        UErrorCode errorCode = U_ZERO_ERROR;
+        m_iterator = icu::BreakIterator::createCharacterInstance(currentTextBreakLocaleID(), errorCode);
+        ASSERT_WITH_MESSAGE(U_SUCCESS(errorCode), "ICU could not open a break iterator: %s (%d)", u_errorName(errorCode), errorCode);
+    }
+
+    m_iterator->setText(icu::UnicodeString(buffer, length));
 }
 
 NonSharedCharacterBreakIterator::~NonSharedCharacterBreakIterator()
 {
     if (m_is8Bit)
         return;
     if (!compareAndSwapNonSharedCharacterBreakIterator(0, m_iterator))
-        ubrk_close(reinterpret_cast<UBreakIterator*>(m_iterator));
+        delete m_iterator;
 }
 
 int NonSharedCharacterBreakIterator::next()
 {
     if (!m_is8Bit)
-        return textBreakNext(m_iterator);
+        return m_iterator->next();
 
     if (m_offset >= m_length)
         return TextBreakDone;
 
     m_offset += clusterLengthStartingAt(m_offset);
     return m_offset;
 }
 
 int NonSharedCharacterBreakIterator::current()
 {
     if (!m_is8Bit)
-        return textBreakCurrent(m_iterator);
+        return m_iterator->current();
     return m_offset;
 }
 
 bool NonSharedCharacterBreakIterator::isBreak(int offset) const
 {
     if (!m_is8Bit)
-        return isTextBreak(m_iterator, offset);
+        return m_iterator->isBoundary(offset);
     return !isLFAfterCR(offset);
 }
 
 int NonSharedCharacterBreakIterator::preceding(int offset) const
 {
     if (!m_is8Bit)
-        return textBreakPreceding(m_iterator, offset);
+        return m_iterator->preceding(offset);
     if (offset <= 0)
         return TextBreakDone;
     if (isLFAfterCR(offset))
         return offset - 2;
     return offset - 1;
 }
 
 int NonSharedCharacterBreakIterator::following(int offset) const
 {
     if (!m_is8Bit)
-        return textBreakFollowing(m_iterator, offset);
+        return m_iterator->following(offset);
     if (static_cast<unsigned>(offset) >= m_length)
         return TextBreakDone;
     return offset + clusterLengthStartingAt(offset);
 }
 
 TextBreakIterator* sentenceBreakIterator(const UChar* string, int length)
 {
-    static bool createdSentenceBreakIterator = false;
-    static TextBreakIterator* staticSentenceBreakIterator;
-    return setUpIterator(createdSentenceBreakIterator,
-        staticSentenceBreakIterator, UBRK_SENTENCE, string, length);
-}
+    UErrorCode openStatus = U_ZERO_ERROR;
+    static TextBreakIterator* iterator = 0;
+    if (!iterator) {
+        iterator =  icu::BreakIterator::createSentenceInstance(currentTextBreakLocaleID(), openStatus);
+        ASSERT_WITH_MESSAGE(U_SUCCESS(openStatus), "ICU could not open a break iterator: %s (%d)", u_errorName(openStatus), openStatus);
+        if (!iterator)
+            return 0;
+    }
 
-int textBreakFirst(TextBreakIterator* iterator)
-{
-    return ubrk_first(reinterpret_cast<UBreakIterator*>(iterator));
-}
-
-int textBreakLast(TextBreakIterator* iterator)
-{
-    return ubrk_last(reinterpret_cast<UBreakIterator*>(iterator));
-}
-
-int textBreakNext(TextBreakIterator* iterator)
-{
-    return ubrk_next(reinterpret_cast<UBreakIterator*>(iterator));
-}
-
-int textBreakPrevious(TextBreakIterator* iterator)
-{
-    return ubrk_previous(reinterpret_cast<UBreakIterator*>(iterator));
-}
-
-int textBreakPreceding(TextBreakIterator* iterator, int pos)
-{
-    return ubrk_preceding(reinterpret_cast<UBreakIterator*>(iterator), pos);
-}
-
-int textBreakFollowing(TextBreakIterator* iterator, int pos)
-{
-    return ubrk_following(reinterpret_cast<UBreakIterator*>(iterator), pos);
-}
-
-int textBreakCurrent(TextBreakIterator* iterator)
-{
-    return ubrk_current(reinterpret_cast<UBreakIterator*>(iterator));
-}
-
-bool isTextBreak(TextBreakIterator* iterator, int position)
-{
-    return ubrk_isBoundary(reinterpret_cast<UBreakIterator*>(iterator), position);
+    iterator->setText(icu::UnicodeString(string, length));
+    return iterator;
 }
 
 bool isWordTextBreak(TextBreakIterator* iterator)
 {
-    int ruleStatus = ubrk_getRuleStatus(reinterpret_cast<UBreakIterator*>(iterator));
+    int ruleStatus = iterator->getRuleStatus();
     return ruleStatus != UBRK_WORD_NONE;
 }
 
-static TextBreakIterator* setUpIteratorWithRules(bool& createdIterator, TextBreakIterator*& iterator,
-    const char* breakRules, const UChar* string, int length)
+static TextBreakIterator* setUpIteratorWithRules(const char* breakRules, const UChar* string, int length)
 {
     if (!string)
         return 0;
 
-    if (!createdIterator) {
-        UParseError parseStatus;
-        UErrorCode openStatus = U_ZERO_ERROR;
-        Vector<UChar> rules;
-        String(breakRules).appendTo(rules);
-        iterator = reinterpret_cast<TextBreakIterator*>(ubrk_openRules(rules.data(), rules.size(), 0, 0, &parseStatus, &openStatus));
-        createdIterator = true;
+    static TextBreakIterator* iterator = 0;
+    UParseError parseStatus;
+    UErrorCode openStatus = U_ZERO_ERROR;
+    Vector<UChar> rules;
+    String(breakRules).appendTo(rules);
+    if (!iterator) {
+        iterator = new icu::RuleBasedBreakIterator(icu::UnicodeString(rules.data(), rules.size()), parseStatus, openStatus);
         ASSERT_WITH_MESSAGE(U_SUCCESS(openStatus), "ICU could not open a break iterator: %s (%d)", u_errorName(openStatus), openStatus);
+        if (!iterator)
+            return 0;
     }
-    if (!iterator)
-        return 0;
 
-    UErrorCode setTextStatus = U_ZERO_ERROR;
-    ubrk_setText(reinterpret_cast<UBreakIterator*>(iterator), string, length, &setTextStatus);
-    if (U_FAILURE(setTextStatus))
-        return 0;
-
+    iterator->setText(icu::UnicodeString(string, length));
     return iterator;
 }
 
 TextBreakIterator* cursorMovementIterator(const UChar* string, int length)
 {
     // This rule set is based on character-break iterator rules of ICU 4.0
     // <http://source.icu-project.org/repos/icu/icu/tags/release-4-0/source/data/brkitr/char.txt>.
     // The major differences from the original ones are listed below:
     // * Replaced '[\p{Grapheme_Cluster_Break = SpacingMark}]' with '[\p{General_Category = Spacing Mark} - $Extend]' for ICU 3.8 or earlier;
     // * Removed rules that prevent a cursor from moving after prepend characters (Bug 24342);
@@ skipping 67 matching lines @@
         "$Hin1 $HinV $Hin0;"               // Devanagari Virama (backward)
         "$Ben1 $BenV $Ben0;"               // Bengali Virama (backward)
         "$Pan1 $PanV $Pan0;"               // Gurmukhi Virama (backward)
         "$Guj1 $GujV $Guj0;"               // Gujarati Virama (backward)
         "$Ori1 $OriV $Ori0;"               // Gujarati Virama (backward)
         "$Tel1 $TelV $Tel0;"               // Telugu Virama (backward)
         "$Kan1 $KanV $Kan0;"               // Kannada Virama (backward)
         "$Mal1 $MalV $Mal0;"               // Malayalam Virama (backward)
         "!!safe_reverse;"
         "!!safe_forward;";
-    static bool createdCursorMovementIterator = false;
-    static TextBreakIterator* staticCursorMovementIterator;
-    return setUpIteratorWithRules(createdCursorMovementIterator, staticCursorMovementIterator, kRules, string, length);
+
+    return setUpIteratorWithRules(kRules, string, length);
 }
 
 }