Decouple l10n_util from InputMethodUtil.

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>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_service.h"
 #include "base/string_util.h"
 #include "base/strings/string_split.h"
 #include "base/utf_string_conversions.h"
 #include "chromeos/ime/component_extension_ime_manager.h"
 #include "chromeos/ime/extension_ime_util.h"
 #include "chromeos/ime/input_method_delegate.h"
+// TODO(nona): move this header from this file.
 #include "grit/generated_resources.h"
-#include "third_party/icu/public/common/unicode/uloc.h"
-#include "ui/base/l10n/l10n_util.h"
-#include "ui/base/l10n/l10n_util_collator.h"
 
 namespace {
 
 // A mapping from an input method id to a string for the language indicator. The
 // mapping is necessary since some input methods belong to the same language.
 // For example, both "xkb:us::eng" and "xkb:us:dvorak:eng" are for US English.
 const struct {
   const char* input_method_id;
   const char* indicator_text;
 } kMappingFromIdToIndicatorText[] = {
@@ skipping 217 matching lines @@
   { "xkb:ca:eng:eng", IDS_STATUSBAR_LAYOUT_CANADA_ENGLISH },
   { "xkb:il::heb", IDS_STATUSBAR_LAYOUT_ISRAEL },
   { "xkb:kr:kr104:kor", IDS_STATUSBAR_LAYOUT_KOREA_104 },
   { "xkb:is::ice", IDS_STATUSBAR_LAYOUT_ICELANDIC },
 
   { "english-m", IDS_STATUSBAR_LAYOUT_USA_MYSTERY },
 };
 const size_t kEnglishToResourceIdArraySize =
     arraysize(kEnglishToResourceIdArray);
 
-// The comparator is used for sorting language codes by their
-// corresponding language names, using the ICU collator.
-struct CompareLanguageCodesByLanguageName
-    : std::binary_function<const std::string&, const std::string&, bool> {
-  CompareLanguageCodesByLanguageName(InputMethodUtil* util,
-                                     icu::Collator* collator)
-      : util_(util), collator_(collator) {
-  }
-
-  // Calling GetLanguageDisplayNameFromCode() in the comparator is not
-  // efficient, but acceptable as the function is cheap, and the language
-  // list is short (about 60 at most).
-  bool operator()(const std::string& s1, const std::string& s2) const {
-    const string16 key1 = util_->GetLanguageDisplayNameFromCode(s1);
-    const string16 key2 = util_->GetLanguageDisplayNameFromCode(s2);
-    return l10n_util::StringComparator<string16>(collator_)(key1, key2);
-  }
-
- private:
-  InputMethodUtil* util_;
-  icu::Collator* collator_;
-};
-
 // The list of language that do not have associated input methods in IBus.
 // For these languages, we associate input methods here.
 const struct ExtraLanguage {
   const char* language_code;
   const char* input_method_id;
 } kExtraLanguages[] = {
   // Language Code  Input Method ID
   { "en-AU", "xkb:us::eng" },  // For Austrailia, use US keyboard layout.
   { "id", "xkb:us::eng" },  // For Indonesian, use US keyboard layout.
   // The code "fil" comes from l10_util.cc.
@@ skipping 40 matching lines @@
   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 = l10n_util::GetStringUTF16(iter->second);
+  *out_string = delegate_->GetLocalizedString(iter->second);
   return true;
 }
 
 string16 InputMethodUtil::TranslateString(
     const std::string& english_string) const {
   string16 localized_string;
   if (TranslateStringInternal(english_string, &localized_string)) {
     return localized_string;
   }
   return UTF8ToUTF16(english_string);
@@ skipping 86 matching lines @@
 }
 
 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 l10n_util::GetStringUTF16(
+      return delegate_->GetLocalizedString(
           kMappingImeIdToMediumLenNameResourceId[i].resource_id);
     }
   }
   return GetInputMethodShortName(input_method);
 }
 
 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 = l10n_util::GetStringUTF16(
+  const string16 standard_input_method_text = delegate_->GetLocalizedString(
       IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_STANDARD_INPUT_METHOD);
   const std::string language_code = input_method.language_code();
 
   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 = l10n_util::GetDisplayNameForLocale(
-        language_code, delegate_->GetActiveLocale(), true);
+    const string16 language_name = delegate_->GetDisplayLanguageName(
+        language_code);
 
     text = language_name + UTF8ToUTF16(" - ") + text;
   }
 
   DCHECK(!text.empty());
   return text;
 }
 
 const InputMethodDescriptor* InputMethodUtil::GetInputMethodDescriptorFromId(
     const std::string& input_method_id) const {
   InputMethodIdToDescriptorMap::const_iterator iter
       = id_to_descriptor_.find(input_method_id);
   return (iter == id_to_descriptor_.end()) ? NULL : &(iter->second);
 }
 
-// static
-string16 InputMethodUtil::GetLanguageDisplayNameFromCode(
-    const std::string& language_code) {
-  return l10n_util::GetDisplayNameForLocale(
-      language_code, delegate_->GetActiveLocale(), true);
-}
-
-// static
-string16 InputMethodUtil::GetLanguageNativeDisplayNameFromCode(
-    const std::string& language_code) {
-  return l10n_util::GetDisplayNameForLocale(language_code, language_code, true);
-}
-
 std::vector<std::string> InputMethodUtil::GetExtraLanguageCodesFromId(
     const std::string& input_method_id) const {
   std::vector<std::string> result;
   for (size_t i = 0; i < kExtraLanguagesLength; ++i) {
     if (input_method_id == kExtraLanguages[i].input_method_id)
       result.push_back(kExtraLanguages[i].language_code);
   }
   return result;
 }
 
@@ skipping 175 matching lines @@
     if (iter != id_to_descriptor_.end()) {
       const InputMethodDescriptor& input_method = iter->second;
       language_code_to_ids_.insert(
           std::make_pair(language_code, input_method.id()));
     }
   }
 }
 
 }  // namespace input_method
 }  // namespace chromeos