Extract a delegate interface from c/b/input_method to permit decoupling from c/b.

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/public/pref_service_base.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
-#include "chrome/browser/browser_process.h"
-#include "chrome/browser/prefs/pref_service.h"
-#include "chrome/common/pref_names.h"
+#include "chrome/browser/chromeos/input_method/input_method_delegate.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/l10n_util_collator.h"
 #include "unicode/uloc.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.
@@ skipping 45 matching lines @@
   { "mozc-chewing", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL },
   { "mozc-dv", IDS_LANGUAGES_MEDIUM_LEN_NAME_JAPANESE },
   { "mozc-hangul", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN },
   { "mozc-jp", IDS_LANGUAGES_MEDIUM_LEN_NAME_JAPANESE },
   { "pinyin", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_SIMPLIFIED },
   { "pinyin-dv", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_SIMPLIFIED },
 };
 const size_t kMappingImeIdToMediumLenNameResourceIdLen =
     ARRAYSIZE_UNSAFE(kMappingImeIdToMediumLenNameResourceId);
 
-string16 GetLanguageName(const std::string& language_code) {
-  const string16 language_name = l10n_util::GetDisplayNameForLocale(
-      language_code, g_browser_process->GetApplicationLocale(), true);
-  return language_name;
-}
-
-}
+}  // namespace
 
 namespace chromeos {
 
 extern const char* kExtensionImePrefix;
 
 namespace input_method {
 
 namespace {
 
 const struct EnglishToResouceId {
@@ skipping 158 matching lines @@
 
   { "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> {
-  explicit CompareLanguageCodesByLanguageName(icu::Collator* collator)
-      : collator_(collator) {
+  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 = InputMethodUtil::GetLanguageDisplayNameFromCode(s1);
-    const string16 key2 = InputMethodUtil::GetLanguageDisplayNameFromCode(s2);
+    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_;
 };
 
 }  // namespace
 
 const ExtraLanguage 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.
   { "fil", "xkb:us::eng" },  // For Filipino, use US keyboard layout.
   // For Netherlands, use US international keyboard layout.
   { "nl", "xkb:us:intl:eng" },
   // The code "es-419" comes from l10_util.cc.
   // For Spanish in Latin America, use Latin American keyboard layout.
   { "es-419", "xkb:latam::spa" },
   // For Malay, use US keyboard layout. crosbug.com/p/8288
   { "ms", "xkb:us::eng" },
 
   // TODO(yusukes): Add {"sw", "xkb:us::eng"} once Swahili is removed from the
   // blacklist in src/ui/base/l10n/l10n_util_posix.cc.
 };
 const size_t kExtraLanguagesLength = arraysize(kExtraLanguages);
 
 InputMethodUtil::InputMethodUtil(
+    InputMethodDelegate* delegate,
     scoped_ptr<InputMethodDescriptors> supported_input_methods)
-    : supported_input_methods_(supported_input_methods.Pass()) {
+    : supported_input_methods_(supported_input_methods.Pass()),
+      delegate_(delegate) {
   ReloadInternalMaps();
 
   // Initialize a map from English string to Chrome string resource ID as well.
   for (size_t i = 0; i < kEnglishToResourceIdArraySize; ++i) {
     const EnglishToResouceId& map_entry = kEnglishToResourceIdArray[i];
     const bool result = english_to_resource_id_.insert(std::make_pair(
         map_entry.english_string_from_ibus, map_entry.resource_id)).second;
     DCHECK(result) << "Duplicated string is found: "
                    << map_entry.english_string_from_ibus;
   }
@@ skipping 156 matching lines @@
   // Indic languages: they share "Standard Input Method".
   const string16 standard_input_method_text = l10n_util::GetStringUTF16(
       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") {
-    text = GetLanguageName(language_code) + UTF8ToUTF16(" - ") + text;
+    const string16 language_name = l10n_util::GetDisplayNameForLocale(
+        language_code, delegate_->GetActiveLocale(), true);
+
+    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);
 }
 
 const InputMethodDescriptor* InputMethodUtil::GetInputMethodDescriptorFromXkbId(
     const std::string& xkb_id) const {
   InputMethodIdToDescriptorMap::const_iterator iter
       = xkb_id_to_descriptor_.find(xkb_id);
   return (iter == xkb_id_to_descriptor_.end()) ? NULL : &(iter->second);
 }
 
 // static
 string16 InputMethodUtil::GetLanguageDisplayNameFromCode(
     const std::string& language_code) {
-  if (!g_browser_process) {
-    return string16();
-  }
   return l10n_util::GetDisplayNameForLocale(
-      language_code, g_browser_process->GetApplicationLocale(), true);
+      language_code, delegate_->GetActiveLocale(), true);
 }
 
 // static
 string16 InputMethodUtil::GetLanguageNativeDisplayNameFromCode(
     const std::string& language_code) {
   return l10n_util::GetDisplayNameForLocale(language_code, language_code, true);
 }
 
-// static
 void InputMethodUtil::SortLanguageCodesByNames(
     std::vector<std::string>* language_codes) {
-  if (!g_browser_process) {
-    return;
-  }
   // We should build collator outside of the comparator. We cannot have
   // scoped_ptr<> in the comparator for a subtle STL reason.
   UErrorCode error = U_ZERO_ERROR;
-  icu::Locale locale(g_browser_process->GetApplicationLocale().c_str());
+  icu::Locale locale(delegate_->GetActiveLocale().c_str());
   scoped_ptr<icu::Collator> collator(
       icu::Collator::createInstance(locale, error));
   if (U_FAILURE(error)) {
     collator.reset();
   }
   std::sort(language_codes->begin(), language_codes->end(),
-            CompareLanguageCodesByLanguageName(collator.get()));
+            CompareLanguageCodesByLanguageName(this, collator.get()));
 }
 
 bool InputMethodUtil::GetInputMethodIdsFromLanguageCode(
     const std::string& normalized_language_code,
     InputMethodType type,
     std::vector<std::string>* out_input_method_ids) const {
   return GetInputMethodIdsFromLanguageCodeInternal(
       language_code_to_ids_,
       normalized_language_code, type, out_input_method_ids);
 }
@@ skipping 89 matching lines @@
     const std::string language_code = input_method->language_code();
     // Add it if it's not already present.
     if (std::count(out_language_codes->begin(), out_language_codes->end(),
                    language_code) == 0) {
       out_language_codes->push_back(language_code);
     }
   }
 }
 
 std::string InputMethodUtil::GetHardwareInputMethodId() const {
-  if (!hardware_input_method_id_for_testing_.empty()) {
-    return hardware_input_method_id_for_testing_;
-  }
+  const std::string input_method_id = delegate_->GetHardwareKeyboardLayout();
 
-  if (!(g_browser_process && g_browser_process->local_state())) {
-    // This shouldn't happen but just in case.
-    DVLOG(1) << "Local state is not yet ready";
-    return InputMethodDescriptor::GetFallbackInputMethodDescriptor().id();
-  }
-
-  PrefService* local_state = g_browser_process->local_state();
-  if (!local_state->FindPreference(prefs::kHardwareKeyboardLayout)) {
-    // This could happen in unittests. We register the preference in
-    // BrowserMain::InitializeLocalState and that method is not called during
-    // unittests.
-    DVLOG(1) << prefs::kHardwareKeyboardLayout << " is not registered";
-    return InputMethodDescriptor::GetFallbackInputMethodDescriptor().id();
-  }
-
-  const std::string input_method_id =
-      local_state->GetString(prefs::kHardwareKeyboardLayout);
   if (input_method_id.empty()) {
     // This is totally fine if it's empty. The hardware keyboard layout is
     // not stored if startup_manifest.json (OEM customization data) is not
     // present (ex. Cr48 doen't have that file).
     return InputMethodDescriptor::GetFallbackInputMethodDescriptor().id();
   }
   return input_method_id;
 }
 
 void InputMethodUtil::ReloadInternalMaps() {
@@ skipping 38 matching lines @@
       language_code_to_ids_.insert(
           std::make_pair(language_code, input_method.id()));
     }
   }
 }
 
 void InputMethodUtil::OnLocaleChanged() {
   ReloadInternalMaps();
 }
 
-void InputMethodUtil::SetHardwareInputMethodIdForTesting(
-    const std::string& input_method_id) {
-  hardware_input_method_id_for_testing_ = input_method_id;
-}
-
 }  // namespace input_method
 }  // namespace chromeos