chromeos: Move InputMethodUtil into //ui/base/ime/chromeos

ui/base/ime/chromeos/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 "ui/base/ime/chromeos/input_method_util.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <functional>
 #include <map>
 #include <memory>
 #include <unordered_set>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/common/extensions/extension_constants.h"
-// TODO(nona): move this header from this file.
-#include "chrome/grit/generated_resources.h"
-#include "components/prefs/pref_service.h"
 #include "ui/base/ime/chromeos/component_extension_ime_manager.h"
 #include "ui/base/ime/chromeos/extension_ime_util.h"
 // For SetHardwareKeyboardLayoutForTesting.
 #include "ui/base/ime/chromeos/fake_input_method_delegate.h"
 #include "ui/base/ime/chromeos/input_method_delegate.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "ui/chromeos/strings/grit/ui_chromeos_strings.h"
 
 namespace {
 
 // A mapping from an input method id to a resource id for a
 // medium length language indicator.
 // For those languages that want to display a slightly longer text in the
 // "Your input method has changed to..." bubble than in the status tray.
 // If an entry is not found in this table the short name is used.
 const struct {
   const char* engine_id;
   const int resource_id;
 } kMappingImeIdToMediumLenNameResourceId[] = {
   { "hangul_2set", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN },
   { "hangul_3set390", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN },
   { "hangul_3setfinal", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN },
   { "hangul_3setnoshift", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN },
   { "hangul_3setromaja", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN },
   { "zh-t-i0-pinyin", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_SIMPLIFIED},
   { "zh-t-i0-wubi-1986", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_SIMPLIFIED },
   { "zh-hant-t-i0-und", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL },
   { "zh-hant-t-i0-cangjie-1987",
     IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL },
   { "zh-hant-t-i0-cangjie-1987-x-m0-simplified",
     IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL },
-  { extension_misc::kBrailleImeEngineId,
+  { chromeos::extension_ime_util::kBrailleImeEngineId,
     IDS_LANGUAGES_MEDIUM_LEN_NAME_BRAILLE },
 };
 const size_t kMappingImeIdToMediumLenNameResourceIdLen =
     arraysize(kMappingImeIdToMediumLenNameResourceId);
 
 // Due to asynchronous initialization of component extension manager,
 // GetFirstLoginInputMethodIds may miss component extension IMEs. To enable
 // component extension IME as the first loging input method, we have to prepare
 // component extension IME IDs.
 // Note: empty layout means the rule applies for all layouts.
@@ skipping 316 matching lines @@
   // 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;
   }
 }
 
-InputMethodUtil::~InputMethodUtil() {
-}
+InputMethodUtil::~InputMethodUtil() {}
 
 std::string InputMethodUtil::GetLocalizedDisplayName(
     const InputMethodDescriptor& descriptor) const {
   // Localizes the input method name.
   const std::string& disp = descriptor.name();
   if (base::StartsWith(disp, "__MSG_", base::CompareCase::SENSITIVE)) {
     const InputMethodNameMap* map = kInputMethodNameMap;
     size_t map_size = arraysize(kInputMethodNameMap);
     std::string name = base::ToUpperASCII(disp);
     const InputMethodNameMap map_key = {name.c_str(), 0};
@@ skipping 119 matching lines @@
   if (language_code == "de" || language_code == "fr" || language_code == "nl") {
     const base::string16 language_name = delegate_->GetDisplayLanguageName(
         language_code);
     text = language_name + base::UTF8ToUTF16(" - ") + text;
   }
 
   DCHECK(!text.empty());
   return text;
 }
 
-
 base::string16 InputMethodUtil::GetInputMethodLongNameStripped(
     const InputMethodDescriptor& input_method) const {
   return GetInputMethodLongNameInternal(input_method, true /* short_name */);
 }
 
 base::string16 InputMethodUtil::GetInputMethodLongName(
     const InputMethodDescriptor& input_method) const {
   return GetInputMethodLongNameInternal(input_method, false /* short_name */);
 }
 
@@ skipping 44 matching lines @@
 void InputMethodUtil::GetFirstLoginInputMethodIds(
     const std::string& language_code,
     const InputMethodDescriptor& preferred_input_method,
     std::vector<std::string>* out_input_method_ids) const {
   out_input_method_ids->clear();
 
   // First, add the preferred keyboard layout (e.g. one used on the login
   // screen or set in UserContext when starting a public session).
   out_input_method_ids->push_back(preferred_input_method.id());
 
-  const std::string current_layout
-      = preferred_input_method.GetPreferredKeyboardLayout();
-  for (size_t i = 0; i < arraysize(kDefaultInputMethodRecommendation);
-       ++i) {
-    if (kDefaultInputMethodRecommendation[i].locale == language_code && (
-        !kDefaultInputMethodRecommendation[i].layout[0] ||
-        kDefaultInputMethodRecommendation[i].layout == current_layout)) {
+  const std::string current_layout =
+      preferred_input_method.GetPreferredKeyboardLayout();
+  for (size_t i = 0; i < arraysize(kDefaultInputMethodRecommendation); ++i) {
+    if (kDefaultInputMethodRecommendation[i].locale == language_code &&
+        (!kDefaultInputMethodRecommendation[i].layout[0] ||
+         kDefaultInputMethodRecommendation[i].layout == current_layout)) {
       out_input_method_ids->push_back(
           extension_ime_util::GetInputMethodIDByEngineID(
               kDefaultInputMethodRecommendation[i].engine_id));
       return;
     }
   }
 
   std::vector<std::string> input_method_ids;
   GetInputMethodIdsFromLanguageCode(
       language_code, kAllInputMethods, &input_method_ids);
@@ skipping 45 matching lines @@
   for (size_t j = 0; j < arraysize(kEngineIdMigrationMap); ++j) {
     size_t pos = engine_id.find(kEngineIdMigrationMap[j][0]);
     if (pos == 0) {
       engine_id.replace(0,
                         strlen(kEngineIdMigrationMap[j][0]),
                         kEngineIdMigrationMap[j][1]);
       break;
     }
   }
   // Migrates the extension IDs.
-  std::string id =
-      extension_ime_util::GetInputMethodIDByEngineID(engine_id);
+  std::string id = extension_ime_util::GetInputMethodIDByEngineID(engine_id);
   if (extension_ime_util::IsComponentExtensionIME(id)) {
     std::string id_new = extension_ime_util::GetInputMethodIDByEngineID(
         extension_ime_util::GetComponentIDByInputMethodID(id));
     if (extension_ime_util::IsComponentExtensionIME(id_new))
       id = id_new;
   }
   return id;
 }
 
 bool InputMethodUtil::MigrateInputMethods(
@@ skipping 65 matching lines @@
   }
 }
 
 void InputMethodUtil::SetHardwareKeyboardLayoutForTesting(
     const std::string& layout) {
   delegate_->SetHardwareKeyboardLayoutForTesting(layout);
   cached_hardware_layouts_.clear();
   UpdateHardwareLayoutCache();
 }
 
-const std::vector<std::string>&
-    InputMethodUtil::GetHardwareInputMethodIds() {
+const std::vector<std::string>& InputMethodUtil::GetHardwareInputMethodIds() {
   DCHECK(thread_checker_.CalledOnValidThread());
   UpdateHardwareLayoutCache();
   return hardware_layouts_;
 }
 
 const std::vector<std::string>&
-    InputMethodUtil::GetHardwareLoginInputMethodIds() {
+InputMethodUtil::GetHardwareLoginInputMethodIds() {
   DCHECK(thread_checker_.CalledOnValidThread());
   UpdateHardwareLayoutCache();
   return hardware_login_layouts_;
 }
 
 bool InputMethodUtil::IsLoginKeyboard(const std::string& input_method_id)
     const {
   const InputMethodDescriptor* ime =
       GetInputMethodDescriptorFromId(input_method_id);
   return ime ? ime->is_login_keyboard() : false;
@@ skipping 53 matching lines @@
       "US",
       layouts,
       languages,
       true,  // login keyboard.
       GURL(),  // options page, not available.
       GURL()); // input view page, not available.
 }
 
 }  // namespace input_method
 }  // namespace chromeos