Fix build with system ICU

components/spellcheck/renderer/spellcheck_worditerator.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Implements a custom word iterator used for our spellchecker.
 
 #include "components/spellcheck/renderer/spellcheck_worditerator.h"
 
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/spellcheck/renderer/spellcheck.h"
 #include "third_party/icu/source/common/unicode/normlzr.h"
 #include "third_party/icu/source/common/unicode/schriter.h"
 #include "third_party/icu/source/common/unicode/uscript.h"
 #include "third_party/icu/source/i18n/unicode/ulocdata.h"
 
-using base::i18n::BreakIterator;
-
 // SpellcheckCharAttribute implementation:
 
 SpellcheckCharAttribute::SpellcheckCharAttribute()
     : script_code_(USCRIPT_LATIN) {
 }
 
 SpellcheckCharAttribute::~SpellcheckCharAttribute() {
 }
 
 void SpellcheckCharAttribute::SetDefaultLanguage(const std::string& language) {
@@ skipping 288 matching lines @@
     bool allow_contraction) {
   // Create a custom ICU break iterator with empty text used in this object. (We
   // allow setting text later so we can re-use this iterator.)
   DCHECK(attribute);
   const base::string16 rule(attribute->GetRuleSet(allow_contraction));
 
   // If there is no rule set, the attributes were invalid.
   if (rule.empty())
     return false;
 
-  std::unique_ptr<BreakIterator> iterator(
-      new BreakIterator(base::string16(), rule));
+  std::unique_ptr<base::i18n::BreakIterator> iterator(

[groby-ooo-7-16, 2016/08/29 17:37:12]

Tiny nit: While you're here, would you mind switching to MakeUnique<>?

[Paweł Hajdan Jr., 2016/08/30 08:29:17]

Done.

+      new base::i18n::BreakIterator(base::string16(), rule));
   if (!iterator->Init()) {
     // Since we're not passing in any text, the only reason this could fail
     // is if we fail to parse the rules. Since the rules are hardcoded,
     // that would be a bug in this class.
     NOTREACHED() << "failed to open iterator (broken rules)";
     return false;
   }
   iterator_ = std::move(iterator);
 
   // Set the character attributes so we can normalize the words extracted by
@@ skipping 34 matching lines @@
     return IS_END_OF_TEXT;
   }
 
   // Find a word that can be checked for spelling or a character that can be
   // skipped over. Rather than moving past a skippable character this returns
   // IS_SKIPPABLE and defers handling the character to the calling function.
   while (iterator_->Advance()) {
     const size_t start = iterator_->prev();
     const size_t length = iterator_->pos() - start;
     switch (iterator_->GetWordBreakStatus()) {
-      case BreakIterator::IS_WORD_BREAK: {
+      case base::i18n::BreakIterator::IS_WORD_BREAK: {
         if (Normalize(start, length, word_string)) {
           *word_start = start;
           *word_length = length;
           return IS_WORD;
         }
         break;
       }
-      case BreakIterator::IS_SKIPPABLE_WORD: {
+      case base::i18n::BreakIterator::IS_SKIPPABLE_WORD: {
         *word_string = iterator_->GetString();
         *word_start = start;
         *word_length = length;
         return IS_SKIPPABLE;
       }
       // |iterator_| is RULE_BASED so the break status should never be
       // IS_LINE_OR_CHAR_BREAK.
-      case BreakIterator::IS_LINE_OR_CHAR_BREAK: {
+      case base::i18n::BreakIterator::IS_LINE_OR_CHAR_BREAK: {
         NOTREACHED();
         break;
       }
     }
   }
 
   // There aren't any more words in the given text.
   return IS_END_OF_TEXT;
 }
 
@@ skipping 18 matching lines @@
   if (status != U_ZERO_ERROR && status != U_STRING_NOT_TERMINATED_WARNING)
     return false;
 
   // Copy the normalized text to the output.
   icu::StringCharacterIterator it(output);
   for (UChar c = it.first(); c != icu::CharacterIterator::DONE; c = it.next())
     attribute_->OutputChar(c, output_string);
 
   return !output_string->empty();
 }