Replace string16 with base::string16.

chrome/browser/chromeos/input_method/input_method_util.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.
 
 #include "chrome/browser/chromeos/input_method/input_method_util.h"
 
 #include <algorithm>
 #include <functional>
 #include <map>
 #include <utility>
@@ skipping 298 matching lines @@
         map_entry.english_string_from_ibus, map_entry.resource_id)).second;
     DCHECK(result) << "Duplicated string is found: "
                    << map_entry.english_string_from_ibus;
   }
 }
 
 InputMethodUtil::~InputMethodUtil() {
 }
 
 bool InputMethodUtil::TranslateStringInternal(
-    const std::string& english_string, string16 *out_string) const {
+    const std::string& english_string, base::string16 *out_string) const {
   DCHECK(out_string);
   HashType::const_iterator iter = english_to_resource_id_.find(english_string);
   if (iter == english_to_resource_id_.end()) {
     // TODO(yusukes): Write Autotest which checks if all display names and all
     // property names for supported input methods are listed in the resource
     // ID array (crosbug.com/4572).
     LOG(ERROR) << "Resource ID is not found for: " << english_string;
     return false;
   }
 
   *out_string = delegate_->GetLocalizedString(iter->second);
   return true;
 }
 
-string16 InputMethodUtil::TranslateString(
+base::string16 InputMethodUtil::TranslateString(
     const std::string& english_string) const {
-  string16 localized_string;
+  base::string16 localized_string;
   if (TranslateStringInternal(english_string, &localized_string)) {
     return localized_string;
   }
   return UTF8ToUTF16(english_string);
 }
 
 bool InputMethodUtil::IsValidInputMethodId(
     const std::string& input_method_id) const {
   // We can't check the component extension is whilelisted or not here because
   // it might not be initialized.
@@ skipping 23 matching lines @@
 std::string InputMethodUtil::GetKeyboardLayoutName(
     const std::string& input_method_id) const {
   InputMethodIdToDescriptorMap::const_iterator iter
       = id_to_descriptor_.find(input_method_id);
   return (iter == id_to_descriptor_.end()) ?
       "" : iter->second.GetPreferredKeyboardLayout();
 }
 
 std::string InputMethodUtil::GetInputMethodDisplayNameFromId(
     const std::string& input_method_id) const {
-  string16 display_name;
+  base::string16 display_name;
   if (!extension_ime_util::IsExtensionIME(input_method_id) &&
       TranslateStringInternal(input_method_id, &display_name)) {
     return UTF16ToUTF8(display_name);
   }
   // Return an empty string if the display name is not found.
   return "";
 }
 
-string16 InputMethodUtil::GetInputMethodShortName(
+base::string16 InputMethodUtil::GetInputMethodShortName(
     const InputMethodDescriptor& input_method) const {
   // For the status area, we use two-letter, upper-case language code like
   // "US" and "JP".
-  string16 text;
+  base::string16 text;
 
   // Check special cases first.
   for (size_t i = 0; i < kMappingFromIdToIndicatorTextLen; ++i) {
     if (kMappingFromIdToIndicatorText[i].input_method_id == input_method.id()) {
       text = UTF8ToUTF16(kMappingFromIdToIndicatorText[i].indicator_text);
       break;
     }
   }
 
   // Display the keyboard layout name when using a keyboard layout.
   if (text.empty() &&
       IsKeyboardLayout(input_method.id())) {
     const size_t kMaxKeyboardLayoutNameLen = 2;
-    const string16 keyboard_layout =
+    const base::string16 keyboard_layout =
         UTF8ToUTF16(GetKeyboardLayoutName(input_method.id()));
     text = StringToUpperASCII(keyboard_layout).substr(
         0, kMaxKeyboardLayoutNameLen);
   }
 
   // TODO(yusukes): Some languages have two or more input methods. For example,
   // Thai has 3, Vietnamese has 4. If these input methods could be activated at
   // the same time, we should do either of the following:
   //   (1) Add mappings to |kMappingFromIdToIndicatorText|
   //   (2) Add suffix (1, 2, ...) to |text| when ambiguous.
 
   if (text.empty()) {
     const size_t kMaxLanguageNameLen = 2;
     DCHECK(!input_method.language_codes().empty());
     const std::string language_code = input_method.language_codes().at(0);
     text = StringToUpperASCII(UTF8ToUTF16(language_code)).substr(
         0, kMaxLanguageNameLen);
   }
   DCHECK(!text.empty());
   return text;
 }
 
-string16 InputMethodUtil::GetInputMethodMediumName(
+base::string16 InputMethodUtil::GetInputMethodMediumName(
     const InputMethodDescriptor& input_method) const {
   // For the "Your input method has changed to..." bubble. In most cases
   // it uses the same name as the short name, unless found in a table
   // for medium length names.
   for (size_t i = 0; i < kMappingImeIdToMediumLenNameResourceIdLen; ++i) {
     if (kMappingImeIdToMediumLenNameResourceId[i].input_method_id ==
         input_method.id()) {
       return delegate_->GetLocalizedString(
           kMappingImeIdToMediumLenNameResourceId[i].resource_id);
     }
   }
   return GetInputMethodShortName(input_method);
 }
 
-string16 InputMethodUtil::GetInputMethodLongName(
+base::string16 InputMethodUtil::GetInputMethodLongName(
     const InputMethodDescriptor& input_method) const {
   if (!input_method.name().empty()) {
     // If the descriptor has a name, use it.
     return UTF8ToUTF16(input_method.name());
   }
 
   // We don't show language here.  Name of keyboard layout or input method
   // usually imply (or explicitly include) its language.
 
   // Special case for German, French and Dutch: these languages have multiple
   // keyboard layouts and share the same layout of keyboard (Belgian). We need
   // to show explicitly the language for the layout. For Arabic, Amharic, and
   // Indic languages: they share "Standard Input Method".
-  const string16 standard_input_method_text = delegate_->GetLocalizedString(
-      IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_STANDARD_INPUT_METHOD);
+  const base::string16 standard_input_method_text =
+      delegate_->GetLocalizedString(
+          IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_STANDARD_INPUT_METHOD);
   DCHECK(!input_method.language_codes().empty());
   const std::string language_code = input_method.language_codes().at(0);
 
-  string16 text = TranslateString(input_method.id());
+  base::string16 text = TranslateString(input_method.id());
   if (text == standard_input_method_text ||
              language_code == "de" ||
              language_code == "fr" ||
              language_code == "nl") {
-    const string16 language_name = delegate_->GetDisplayLanguageName(
+    const base::string16 language_name = delegate_->GetDisplayLanguageName(
         language_code);
 
     text = language_name + UTF8ToUTF16(" - ") + text;
   }
 
   DCHECK(!text.empty());
   return text;
 }
 
 const InputMethodDescriptor* InputMethodUtil::GetInputMethodDescriptorFromId(
@@ skipping 191 matching lines @@
     if (IsKeyboardLayout(input_method.id())) {
       xkb_id_to_descriptor_.insert(
           std::make_pair(input_method.GetPreferredKeyboardLayout(),
                          input_method));
     }
   }
 }
 
 }  // namespace input_method
 }  // namespace chromeos