Use base namespace for string16 in chrome/renderer.

chrome/renderer/spellchecker/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 "chrome/renderer/spellchecker/spellcheck_worditerator.h"
 
 #include <map>
 #include <string>
@@ skipping 14 matching lines @@
     : script_code_(USCRIPT_LATIN) {
 }
 
 SpellcheckCharAttribute::~SpellcheckCharAttribute() {
 }
 
 void SpellcheckCharAttribute::SetDefaultLanguage(const std::string& language) {
   CreateRuleSets(language);
 }
 
-string16 SpellcheckCharAttribute::GetRuleSet(bool allow_contraction) const {
+base::string16 SpellcheckCharAttribute::GetRuleSet(
+    bool allow_contraction) const {
   return allow_contraction ?
       ruleset_allow_contraction_ : ruleset_disallow_contraction_;
 }
 
 void SpellcheckCharAttribute::CreateRuleSets(const std::string& language) {
   // The template for our custom rule sets, which is based on the word-break
   // rules of ICU 4.0:
   // <http://source.icu-project.org/repos/icu/icu/tags/release-4-0/source/data/brkitr/word.txt>.
   // The major differences from the original one are listed below:
   // * It discards comments in the original rules.
@@ skipping 136 matching lines @@
                          kAllowContraction));
   ruleset_disallow_contraction_ = ASCIIToUTF16(
       base::StringPrintf(kRuleTemplate,
                          aletter,
                          aletter_extra,
                          midletter_extra,
                          aletter_plus,
                          kDisallowContraction));
 }
 
-bool SpellcheckCharAttribute::OutputChar(UChar c, string16* output) const {
+bool SpellcheckCharAttribute::OutputChar(UChar c,
+                                         base::string16* output) const {
   // Call the language-specific function if necessary.
   // Otherwise, we call the default one.
   switch (script_code_) {
     case USCRIPT_ARABIC:
       return OutputArabic(c, output);
 
     case USCRIPT_HANGUL:
       return OutputHangul(c, output);
 
     case USCRIPT_HEBREW:
       return OutputHebrew(c, output);
 
     default:
       return OutputDefault(c, output);
   }
 }
 
-bool SpellcheckCharAttribute::OutputArabic(UChar c, string16* output) const {
+bool SpellcheckCharAttribute::OutputArabic(UChar c,
+                                           base::string16* output) const {
   // Discard characters not from Arabic alphabets. We also discard vowel marks
   // of Arabic (Damma, Fatha, Kasra, etc.) to prevent our Arabic dictionary from
   // marking an Arabic word including vowel marks as misspelled. (We need to
   // check these vowel marks manually and filter them out since their script
   // codes are USCRIPT_ARABIC.)
   if (0x0621 <= c && c <= 0x064D)
     output->push_back(c);
   return true;
 }
 
-bool SpellcheckCharAttribute::OutputHangul(UChar c, string16* output) const {
+bool SpellcheckCharAttribute::OutputHangul(UChar c,
+                                           base::string16* output) const {
   // Decompose a Hangul character to a Hangul vowel and consonants used by our
   // spellchecker. A Hangul character of Unicode is a ligature consisting of a
   // Hangul vowel and consonants, e.g. U+AC01 "Gag" consists of U+1100 "G",
   // U+1161 "a", and U+11A8 "g". That is, we can treat each Hangul character as
   // a point of a cubic linear space consisting of (first consonant, vowel, last
   // consonant). Therefore, we can compose a Hangul character from a vowel and
   // two consonants with linear composition:
   //   character =  0xAC00 +
   //                (first consonant - 0x1100) * 28 * 21 +
   //                (vowel           - 0x1161) * 28 +
@@ skipping 26 matching lines @@
   int l = kLBase + index / kNCount;
   int v = kVBase + (index % kNCount) / kTCount;
   int t = kTBase + index % kTCount;
   output->push_back(l);
   output->push_back(v);
   if (t != kTBase)
     output->push_back(t);
   return true;
 }
 
-bool SpellcheckCharAttribute::OutputHebrew(UChar c, string16* output) const {
+bool SpellcheckCharAttribute::OutputHebrew(UChar c,
+                                           base::string16* output) const {
   // Discard characters except Hebrew alphabets. We also discard Hebrew niqquds
   // to prevent our Hebrew dictionary from marking a Hebrew word including
   // niqquds as misspelled. (Same as Arabic vowel marks, we need to check
   // niqquds manually and filter them out since their script codes are
   // USCRIPT_HEBREW.)
   // Pass through ASCII single/double quotation marks and Hebrew Geresh and
   // Gershayim.
   if ((0x05D0 <= c && c <= 0x05EA) || c == 0x22 || c == 0x27 ||
       c == 0x05F4 || c == 0x05F3)
     output->push_back(c);
   return true;
 }
 
-bool SpellcheckCharAttribute::OutputDefault(UChar c, string16* output) const {
+bool SpellcheckCharAttribute::OutputDefault(UChar c,
+                                            base::string16* output) const {
   // Check the script code of this character and output only if it is the one
   // used by the spellchecker language.
   UErrorCode status = U_ZERO_ERROR;
   UScriptCode script_code = uscript_getScript(c, &status);
   if (script_code == script_code_ || script_code == USCRIPT_COMMON)
     output->push_back(c);
   return true;
 }
 
 // SpellcheckWordIterator implementation:
@@ skipping 11 matching lines @@
 }
 
 bool SpellcheckWordIterator::Initialize(
     const SpellcheckCharAttribute* attribute,
     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);
   UErrorCode open_status = U_ZERO_ERROR;
   UParseError parse_status;
-  string16 rule(attribute->GetRuleSet(allow_contraction));
+  base::string16 rule(attribute->GetRuleSet(allow_contraction));
 
   // If there is no rule set, the attributes were invalid.
   if (rule.empty())
     return false;
 
   iterator_ = ubrk_openRules(rule.c_str(), rule.length(), NULL, 0,
                              &parse_status, &open_status);
   if (U_FAILURE(open_status))
     return false;
 
@@ skipping 22 matching lines @@
   // only of Chinese characters while the spellchecker language is English.)
   position_ = ubrk_first(iterator_);
   if (position_ == UBRK_DONE)
     return false;
 
   text_ = text;
   length_ = static_cast<int>(length);
   return true;
 }
 
-bool SpellcheckWordIterator::GetNextWord(string16* word_string,
+bool SpellcheckWordIterator::GetNextWord(base::string16* word_string,
                                          int* word_start,
                                          int* word_length) {
   DCHECK(!!text_ && length_ > 0);
 
   word_string->clear();
   *word_start = 0;
   *word_length = 0;
 
   if (!text_ || position_ == UBRK_DONE)
     return false;
@@ skipping 26 matching lines @@
 
 void SpellcheckWordIterator::Reset() {
   if (iterator_) {
     ubrk_close(iterator_);
     iterator_ = NULL;
   }
 }
 
 bool SpellcheckWordIterator::Normalize(int input_start,
                                        int input_length,
-                                       string16* output_string) const {
+                                       base::string16* output_string) const {
   // We use NFKC (Normalization Form, Compatible decomposition, followed by
   // canonical Composition) defined in Unicode Standard Annex #15 to normalize
   // this token because it it the most suitable normalization algorithm for our
   // spellchecker. Nevertheless, it is not a perfect algorithm for our
   // spellchecker and we need manual normalization as well. The normalized
   // text does not have to be NUL-terminated since its characters are copied to
   // string16, which adds a NUL character when we need.
   icu::UnicodeString input(FALSE, &text_[input_start], input_length);
   UErrorCode status = U_ZERO_ERROR;
   icu::UnicodeString output;
   icu::Normalizer::normalize(input, UNORM_NFKC, 0, output, status);
   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();
 }