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

Source/core/platform/text/LineBreakIteratorPoolICU.h

 /*
  * Copyright (C) 2011 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 30 matching lines @@
     WTF_MAKE_NONCOPYABLE(LineBreakIteratorPool);
 public:
     static LineBreakIteratorPool& sharedPool()
     {
         static WTF::ThreadSpecific<LineBreakIteratorPool>* pool = new WTF::ThreadSpecific<LineBreakIteratorPool>;
         return **pool;
     }
 
     static PassOwnPtr<LineBreakIteratorPool> create() { return adoptPtr(new LineBreakIteratorPool); }
 
-    UBreakIterator* take(const AtomicString& locale)
+    icu::BreakIterator* take(const AtomicString& locale)
     {
-        UBreakIterator* iterator = 0;
+        icu::BreakIterator* iterator = 0;
         for (size_t i = 0; i < m_pool.size(); ++i) {
             if (m_pool[i].first == locale) {
                 iterator = m_pool[i].second;
                 m_pool.remove(i);
                 break;
             }
         }
 
         if (!iterator) {
             UErrorCode openStatus = U_ZERO_ERROR;
             bool localeIsEmpty = locale.isEmpty();
-            iterator = ubrk_open(UBRK_LINE, localeIsEmpty ? currentTextBreakLocaleID() : locale.string().utf8().data(), 0, 0, &openStatus);
+            iterator = icu::BreakIterator::createLineInstance(localeIsEmpty ? currentTextBreakLocaleID() : locale.string().utf8().data(), openStatus);
             // locale comes from a web page and it can be invalid, leading ICU
             // to fail, in which case we fall back to the default locale.
             if (!localeIsEmpty && U_FAILURE(openStatus)) {
                 openStatus = U_ZERO_ERROR;
-                iterator = ubrk_open(UBRK_LINE, currentTextBreakLocaleID(), 0, 0, &openStatus);
+                iterator = icu::BreakIterator::createLineInstance(currentTextBreakLocaleID(), openStatus);
             }
 
             if (U_FAILURE(openStatus)) {
-                LOG_ERROR("ubrk_open failed with status %d", openStatus);
+                LOG_ERROR("BreakIterator construction failed with status %d", openStatus);
                 return 0;
             }
         }
 
         ASSERT(!m_vendedIterators.contains(iterator));
         m_vendedIterators.set(iterator, locale);
         return iterator;
     }
 
-    void put(UBreakIterator* iterator)
+    void put(icu::BreakIterator* iterator)
     {
         ASSERT_ARG(iterator, m_vendedIterators.contains(iterator));
 
         if (m_pool.size() == capacity) {
-            ubrk_close(m_pool[0].second);
+            delete m_pool[0].second;
             m_pool.remove(0);
         }
 
         m_pool.append(Entry(m_vendedIterators.take(iterator), iterator));
     }
 
 private:
     LineBreakIteratorPool() { }
 
     static const size_t capacity = 4;
 
-    typedef pair<AtomicString, UBreakIterator*> Entry;
+    typedef pair<AtomicString, icu::BreakIterator*> Entry;
     typedef Vector<Entry, capacity> Pool;
     Pool m_pool;
-    HashMap<UBreakIterator*, AtomicString> m_vendedIterators;
+    HashMap<icu::BreakIterator*, AtomicString> m_vendedIterators;
 
     friend WTF::ThreadSpecific<LineBreakIteratorPool>::operator LineBreakIteratorPool*();
 };
 
 }
 
 #endif