chrome/browser/chromeos/input_method/input_method_util.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/chromeos/input_method/input_method_util.h"
   6
   7 #include <algorithm>
   8 #include <functional>
   9 #include <map>
  10 #include <utility>
  11
  12 #include "base/basictypes.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/prefs/pref_service.h"
  15 #include "base/strings/string_split.h"
  16 #include "base/strings/string_util.h"
  17 #include "base/strings/utf_string_conversions.h"
  18 #include "chrome/common/extensions/extension_constants.h"
  19
  20 // TODO(nona): move this header from this file.
  21 #include "chrome/grit/generated_resources.h"
  22
  23 #include "ui/base/ime/chromeos/component_extension_ime_manager.h"
  24 #include "ui/base/ime/chromeos/extension_ime_util.h"
  25
  26 // For SetHardwareKeyboardLayoutForTesting.
  27 #include "ui/base/ime/chromeos/fake_input_method_delegate.h"
  28 #include "ui/base/ime/chromeos/input_method_delegate.h"
  29 #include "ui/base/ime/chromeos/input_method_whitelist.h"
  30
  31 #include "ui/base/l10n/l10n_util.h"
  32
  33 namespace {
  34
  35 // A mapping from an input method id to a resource id for a
  36 // medium length language indicator.
  37 // For those languages that want to display a slightly longer text in the
  38 // "Your input method has changed to..." bubble than in the status tray.
  39 // If an entry is not found in this table the short name is used.
  40 const struct {
  41   const char* engine_id;
  42   const int resource_id;
  43 } kMappingImeIdToMediumLenNameResourceId[] = {
  44   { "hangul_2set", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN },
  45   { "hangul_3set390", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN },
  46   { "hangul_3setfinal", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN },
  47   { "hangul_3setnoshift", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN },
  48   { "hangul_3setromaja", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN },
  49   { "zh-t-i0-pinyin", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_SIMPLIFIED},
  50   { "zh-t-i0-wubi-1986", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_SIMPLIFIED },
  51   { "zh-hant-t-i0-und", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL },
  52   { "zh-hant-t-i0-cangjie-1987",
  53     IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL },
  54   { "zh-hant-t-i0-cangjie-1987-x-m0-simplified",
  55     IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL },
  56   { extension_misc::kBrailleImeEngineId,
  57     IDS_LANGUAGES_MEDIUM_LEN_NAME_BRAILLE },
  58 };
  59 const size_t kMappingImeIdToMediumLenNameResourceIdLen =
  60     arraysize(kMappingImeIdToMediumLenNameResourceId);
  61
  62 // Due to asynchronous initialization of component extension manager,
  63 // GetFirstLoginInputMethodIds may miss component extension IMEs. To enable
  64 // component extension IME as the first loging input method, we have to prepare
  65 // component extension IME IDs.
  66 // Note: empty layout means the rule applies for all layouts.
  67 const struct {
  68   const char* locale;
  69   const char* layout;
  70   const char* engine_id;
  71 } kDefaultInputMethodRecommendation[] = {
  72   { "ja", "jp", "nacl_mozc_jp" },
  73   { "ja", "", "nacl_mozc_us" },
  74   { "zh-CN", "", "zh-t-i0-pinyin" },
  75   { "zh-TW", "", "zh-hant-t-i0-und" },
  76   { "th", "", "vkd_th" },
  77   { "vi", "", "vkd_vi_tcvn" },
  78   { "ru", "", "xkb:ru::rus" },
  79 };
  80
  81 // The engine ID map for migration. This migration is for input method IDs from
  82 // VPD so it's NOT a temporary migration.
  83 const char* const kEngineIdMigrationMap[][2] = {
  84     {"ime:jp:mozc_jp", "nacl_mozc_jp"},
  85     {"ime:jp:mozc_us", "nacl_mozc_us"},
  86     {"ime:ko:hangul_2set", "hangul_2set"},
  87     {"ime:ko:hangul", "hangul_2set"},
  88     {"ime:zh-t:array", "zh-hant-t-i0-array-1992"},
  89     {"ime:zh-t:cangjie", "zh-hant-t-i0-cangjie-1987"},
  90     {"ime:zh-t:dayi", "zh-hant-t-i0-dayi-1988"},
  91     {"ime:zh-t:pinyin", "zh-hant-t-i0-pinyin"},
  92     {"ime:zh-t:quick", "zh-hant-t-i0-cangjie-1987-x-m0-simplified"},
  93     {"ime:zh-t:zhuyin", "zh-hant-t-i0-und"},
  94     {"ime:zh:pinyin", "zh-t-i0-pinyin"},
  95     {"ime:zh:wubi", "zh-t-i0-wubi-1986"},
  96     {"m17n:", "vkd_"},
  97     {"t13n:am", "am-t-i0-und"},
  98     {"t13n:ar", "ar-t-i0-und"},
  99     {"t13n:bn", "bn-t-i0-und"},
 100     {"t13n:el", "el-t-i0-und"},
 101     {"t13n:fa", "fa-t-i0-und"},
 102     {"t13n:gu", "gu-t-i0-und"},
 103     {"t13n:he", "he-t-i0-und"},
 104     {"t13n:hi", "hi-t-i0-und"},
 105     {"t13n:kn", "kn-t-i0-und"},
 106     {"t13n:ml", "ml-t-i0-und"},
 107     {"t13n:mr", "mr-t-i0-und"},
 108     {"t13n:ne", "ne-t-i0-und"},
 109     {"t13n:or", "or-t-i0-und"},
 110     {"t13n:pa", "pa-t-i0-und"},
 111     {"t13n:sa", "sa-t-i0-und"},
 112     {"t13n:sr", "sr-t-i0-und"},
 113     {"t13n:ta", "ta-t-i0-und"},
 114     {"t13n:te", "te-t-i0-und"},
 115     {"t13n:ti", "ti-t-i0-und"},
 116     {"t13n:ur", "ur-t-i0-und"},
 117 };
 118
 119 const struct EnglishToResouceId {
 120   const char* english_string_from_ibus;
 121   int resource_id;
 122 } kEnglishToResourceIdArray[] = {
 123   // For xkb-layouts.
 124   { "xkb:am:phonetic:arm", IDS_STATUSBAR_LAYOUT_ARMENIAN_PHONETIC },
 125   { "xkb:be::fra", IDS_STATUSBAR_LAYOUT_BELGIUM },
 126   { "xkb:be::ger", IDS_STATUSBAR_LAYOUT_BELGIUM },
 127   { "xkb:be::nld", IDS_STATUSBAR_LAYOUT_BELGIUM },
 128   { "xkb:bg::bul", IDS_STATUSBAR_LAYOUT_BULGARIA },
 129   { "xkb:bg:phonetic:bul", IDS_STATUSBAR_LAYOUT_BULGARIA_PHONETIC },
 130   { "xkb:br::por", IDS_STATUSBAR_LAYOUT_BRAZIL },
 131   { "xkb:by::bel", IDS_STATUSBAR_LAYOUT_BELARUSIAN },
 132   { "xkb:ca::fra", IDS_STATUSBAR_LAYOUT_CANADA },
 133   { "xkb:ca:eng:eng", IDS_STATUSBAR_LAYOUT_CANADA_ENGLISH },
 134   { "xkb:ca:multix:fra", IDS_STATUSBAR_LAYOUT_CANADIAN_MULTILINGUAL },
 135   { "xkb:ch::ger", IDS_STATUSBAR_LAYOUT_SWITZERLAND },
 136   { "xkb:ch:fr:fra", IDS_STATUSBAR_LAYOUT_SWITZERLAND_FRENCH },
 137   { "xkb:cz::cze", IDS_STATUSBAR_LAYOUT_CZECHIA },
 138   { "xkb:cz:qwerty:cze", IDS_STATUSBAR_LAYOUT_CZECHIA_QWERTY },
 139   { "xkb:de::ger", IDS_STATUSBAR_LAYOUT_GERMANY },
 140   { "xkb:de:neo:ger", IDS_STATUSBAR_LAYOUT_GERMANY_NEO2 },
 141   { "xkb:dk::dan", IDS_STATUSBAR_LAYOUT_DENMARK },
 142   { "xkb:ee::est", IDS_STATUSBAR_LAYOUT_ESTONIA },
 143   { "xkb:es::spa", IDS_STATUSBAR_LAYOUT_SPAIN },
 144   { "xkb:es:cat:cat", IDS_STATUSBAR_LAYOUT_SPAIN_CATALAN },
 145   { "xkb:fi::fin", IDS_STATUSBAR_LAYOUT_FINLAND },
 146   { "xkb:fr::fra", IDS_STATUSBAR_LAYOUT_FRANCE },
 147   { "xkb:gb:dvorak:eng", IDS_STATUSBAR_LAYOUT_UNITED_KINGDOM_DVORAK },
 148   { "xkb:gb:extd:eng", IDS_STATUSBAR_LAYOUT_UNITED_KINGDOM },
 149   { "xkb:ge::geo", IDS_STATUSBAR_LAYOUT_GEORGIAN },
 150   { "xkb:gr::gre", IDS_STATUSBAR_LAYOUT_GREECE },
 151   { "xkb:hr::scr", IDS_STATUSBAR_LAYOUT_CROATIA },
 152   { "xkb:hu::hun", IDS_STATUSBAR_LAYOUT_HUNGARY },
 153   { "xkb:ie::ga", IDS_STATUSBAR_LAYOUT_IRISH },
 154   { "xkb:il::heb", IDS_STATUSBAR_LAYOUT_ISRAEL },
 155   { "xkb:is::ice", IDS_STATUSBAR_LAYOUT_ICELANDIC },
 156   { "xkb:it::ita", IDS_STATUSBAR_LAYOUT_ITALY },
 157   { "xkb:jp::jpn", IDS_STATUSBAR_LAYOUT_JAPAN },
 158   { "xkb:latam::spa", IDS_STATUSBAR_LAYOUT_LATIN_AMERICAN },
 159   { "xkb:lt::lit", IDS_STATUSBAR_LAYOUT_LITHUANIA },
 160   { "xkb:lv:apostrophe:lav", IDS_STATUSBAR_LAYOUT_LATVIA },
 161   { "xkb:mn::mon", IDS_STATUSBAR_LAYOUT_MONGOLIAN },
 162   { "xkb:nl::nld", IDS_STATUSBAR_LAYOUT_NETHERLANDS },
 163   { "xkb:no::nob", IDS_STATUSBAR_LAYOUT_NORWAY },
 164   { "xkb:pl::pol", IDS_STATUSBAR_LAYOUT_POLAND },
 165   { "xkb:pt::por", IDS_STATUSBAR_LAYOUT_PORTUGAL },
 166   { "xkb:ro::rum", IDS_STATUSBAR_LAYOUT_ROMANIA },
 167   { "xkb:rs::srp", IDS_STATUSBAR_LAYOUT_SERBIA },
 168   { "xkb:ru::rus", IDS_STATUSBAR_LAYOUT_RUSSIA },
 169   { "xkb:ru:phonetic:rus", IDS_STATUSBAR_LAYOUT_RUSSIA_PHONETIC },
 170   { "xkb:se::swe", IDS_STATUSBAR_LAYOUT_SWEDEN },
 171   { "xkb:si::slv", IDS_STATUSBAR_LAYOUT_SLOVENIA },
 172   { "xkb:sk::slo", IDS_STATUSBAR_LAYOUT_SLOVAKIA },
 173   { "xkb:tr::tur", IDS_STATUSBAR_LAYOUT_TURKEY },
 174   { "xkb:ua::ukr", IDS_STATUSBAR_LAYOUT_UKRAINE },
 175   { "xkb:us::eng", IDS_STATUSBAR_LAYOUT_USA },
 176   { "xkb:us::fil", IDS_STATUSBAR_LAYOUT_USA },
 177   { "xkb:us::ind", IDS_STATUSBAR_LAYOUT_USA },
 178   { "xkb:us::msa", IDS_STATUSBAR_LAYOUT_USA },
 179   { "xkb:us:altgr-intl:eng", IDS_STATUSBAR_LAYOUT_USA_EXTENDED },
 180   { "xkb:us:colemak:eng", IDS_STATUSBAR_LAYOUT_USA_COLEMAK },
 181   { "xkb:us:dvorak:eng", IDS_STATUSBAR_LAYOUT_USA_DVORAK },
 182   { "xkb:us:dvp:eng", IDS_STATUSBAR_LAYOUT_USA_DVP },
 183   { "xkb:us:intl:eng", IDS_STATUSBAR_LAYOUT_USA_INTERNATIONAL },
 184   { "xkb:us:intl:nld", IDS_STATUSBAR_LAYOUT_USA_INTERNATIONAL },
 185   { "xkb:us:intl:por", IDS_STATUSBAR_LAYOUT_USA_INTERNATIONAL },
 186 };
 187 const size_t kEnglishToResourceIdArraySize =
 188     arraysize(kEnglishToResourceIdArray);
 189
 190 const struct InputMethodNameMap {
 191   const char* message_name;
 192   int resource_id;
 193   bool operator<(const InputMethodNameMap& other) const {
 194     return strcmp(message_name, other.message_name) < 0;
 195   }
 196 } kInputMethodNameMap[] = {
 197     {"__MSG_INPUTMETHOD_ARRAY__", IDS_IME_NAME_INPUTMETHOD_ARRAY},
 198     {"__MSG_INPUTMETHOD_CANGJIE__", IDS_IME_NAME_INPUTMETHOD_CANGJIE},
 199     {"__MSG_INPUTMETHOD_DAYI__", IDS_IME_NAME_INPUTMETHOD_DAYI},
 200     {"__MSG_INPUTMETHOD_HANGUL_2_SET__", IDS_IME_NAME_INPUTMETHOD_HANGUL_2_SET},
 201     {"__MSG_INPUTMETHOD_HANGUL_3_SET_390__",
 202      IDS_IME_NAME_INPUTMETHOD_HANGUL_3_SET_390},
 203     {"__MSG_INPUTMETHOD_HANGUL_3_SET_FINAL__",
 204      IDS_IME_NAME_INPUTMETHOD_HANGUL_3_SET_FINAL},
 205     {"__MSG_INPUTMETHOD_HANGUL_3_SET_NO_SHIFT__",
 206      IDS_IME_NAME_INPUTMETHOD_HANGUL_3_SET_NO_SHIFT},
 207     {"__MSG_INPUTMETHOD_HANGUL_AHNMATAE__",
 208      IDS_IME_NAME_INPUTMETHOD_HANGUL_AHNMATAE},
 209     {"__MSG_INPUTMETHOD_HANGUL_ROMAJA__",
 210      IDS_IME_NAME_INPUTMETHOD_HANGUL_ROMAJA},
 211     {"__MSG_INPUTMETHOD_HANGUL__", IDS_IME_NAME_INPUTMETHOD_HANGUL},
 212     {"__MSG_INPUTMETHOD_MOZC_JP__", IDS_IME_NAME_INPUTMETHOD_MOZC_JP},
 213     {"__MSG_INPUTMETHOD_MOZC_US__", IDS_IME_NAME_INPUTMETHOD_MOZC_US},
 214     {"__MSG_INPUTMETHOD_PINYIN__", IDS_IME_NAME_INPUTMETHOD_PINYIN},
 215     {"__MSG_INPUTMETHOD_QUICK__", IDS_IME_NAME_INPUTMETHOD_QUICK},
 216     {"__MSG_INPUTMETHOD_TRADITIONAL_PINYIN__",
 217      IDS_IME_NAME_INPUTMETHOD_TRADITIONAL_PINYIN},
 218     {"__MSG_INPUTMETHOD_WUBI__", IDS_IME_NAME_INPUTMETHOD_WUBI},
 219     {"__MSG_INPUTMETHOD_ZHUYIN__", IDS_IME_NAME_INPUTMETHOD_ZHUYIN},
 220     {"__MSG_KEYBOARD_ARABIC__", IDS_IME_NAME_KEYBOARD_ARABIC},
 221     {"__MSG_KEYBOARD_ARMENIAN_PHONETIC__",
 222      IDS_IME_NAME_KEYBOARD_ARMENIAN_PHONETIC},
 223     {"__MSG_KEYBOARD_BELARUSIAN__", IDS_IME_NAME_KEYBOARD_BELARUSIAN},
 224     {"__MSG_KEYBOARD_BELGIAN__", IDS_IME_NAME_KEYBOARD_BELGIAN},
 225     {"__MSG_KEYBOARD_BENGALI_PHONETIC__",
 226      IDS_IME_NAME_KEYBOARD_BENGALI_PHONETIC},
 227     {"__MSG_KEYBOARD_BRAZILIAN__", IDS_IME_NAME_KEYBOARD_BRAZILIAN},
 228     {"__MSG_KEYBOARD_BULGARIAN_PHONETIC__",
 229      IDS_IME_NAME_KEYBOARD_BULGARIAN_PHONETIC},
 230     {"__MSG_KEYBOARD_BULGARIAN__", IDS_IME_NAME_KEYBOARD_BULGARIAN},
 231     {"__MSG_KEYBOARD_CANADIAN_ENGLISH__",
 232      IDS_IME_NAME_KEYBOARD_CANADIAN_ENGLISH},
 233     {"__MSG_KEYBOARD_CANADIAN_FRENCH__", IDS_IME_NAME_KEYBOARD_CANADIAN_FRENCH},
 234     {"__MSG_KEYBOARD_CANADIAN_MULTILINGUAL__",
 235      IDS_IME_NAME_KEYBOARD_CANADIAN_MULTILINGUAL},
 236     {"__MSG_KEYBOARD_CATALAN__", IDS_IME_NAME_KEYBOARD_CATALAN},
 237     {"__MSG_KEYBOARD_CROATIAN__", IDS_IME_NAME_KEYBOARD_CROATIAN},
 238     {"__MSG_KEYBOARD_CZECH_QWERTY__", IDS_IME_NAME_KEYBOARD_CZECH_QWERTY},
 239     {"__MSG_KEYBOARD_CZECH__", IDS_IME_NAME_KEYBOARD_CZECH},
 240     {"__MSG_KEYBOARD_DANISH__", IDS_IME_NAME_KEYBOARD_DANISH},
 241     {"__MSG_KEYBOARD_DEVANAGARI_PHONETIC__",
 242      IDS_IME_NAME_KEYBOARD_DEVANAGARI_PHONETIC},
 243     {"__MSG_KEYBOARD_ESTONIAN__", IDS_IME_NAME_KEYBOARD_ESTONIAN},
 244     {"__MSG_KEYBOARD_ETHIOPIC__", IDS_IME_NAME_KEYBOARD_ETHIOPIC},
 245     {"__MSG_KEYBOARD_FINNISH__", IDS_IME_NAME_KEYBOARD_FINNISH},
 246     {"__MSG_KEYBOARD_FRENCH__", IDS_IME_NAME_KEYBOARD_FRENCH},
 247     {"__MSG_KEYBOARD_GEORGIAN__", IDS_IME_NAME_KEYBOARD_GEORGIAN},
 248     {"__MSG_KEYBOARD_GERMAN_NEO_2__", IDS_IME_NAME_KEYBOARD_GERMAN_NEO_2},
 249     {"__MSG_KEYBOARD_GERMAN__", IDS_IME_NAME_KEYBOARD_GERMAN},
 250     {"__MSG_KEYBOARD_GREEK__", IDS_IME_NAME_KEYBOARD_GREEK},
 251     {"__MSG_KEYBOARD_GUJARATI_PHONETIC__",
 252      IDS_IME_NAME_KEYBOARD_GUJARATI_PHONETIC},
 253     {"__MSG_KEYBOARD_HEBREW__", IDS_IME_NAME_KEYBOARD_HEBREW},
 254     {"__MSG_KEYBOARD_HUNGARIAN__", IDS_IME_NAME_KEYBOARD_HUNGARIAN},
 255     {"__MSG_KEYBOARD_ICELANDIC__", IDS_IME_NAME_KEYBOARD_ICELANDIC},
 256     {"__MSG_KEYBOARD_IRISH__", IDS_IME_NAME_KEYBOARD_IRISH},
 257     {"__MSG_KEYBOARD_ITALIAN__", IDS_IME_NAME_KEYBOARD_ITALIAN},
 258     {"__MSG_KEYBOARD_JAPANESE__", IDS_IME_NAME_KEYBOARD_JAPANESE},
 259     {"__MSG_KEYBOARD_KANNADA_PHONETIC__",
 260      IDS_IME_NAME_KEYBOARD_KANNADA_PHONETIC},
 261     {"__MSG_KEYBOARD_KHMER__", IDS_IME_NAME_KEYBOARD_KHMER},
 262     {"__MSG_KEYBOARD_LAO__", IDS_IME_NAME_KEYBOARD_LAO},
 263     {"__MSG_KEYBOARD_LATIN_AMERICAN__", IDS_IME_NAME_KEYBOARD_LATIN_AMERICAN},
 264     {"__MSG_KEYBOARD_LATVIAN__", IDS_IME_NAME_KEYBOARD_LATVIAN},
 265     {"__MSG_KEYBOARD_LITHUANIAN__", IDS_IME_NAME_KEYBOARD_LITHUANIAN},
 266     {"__MSG_KEYBOARD_MALAYALAM_PHONETIC__",
 267      IDS_IME_NAME_KEYBOARD_MALAYALAM_PHONETIC},
 268     {"__MSG_KEYBOARD_MALTESE__", IDS_IME_NAME_KEYBOARD_MALTESE},
 269     {"__MSG_KEYBOARD_MONGOLIAN__", IDS_IME_NAME_KEYBOARD_MONGOLIAN},
 270     {"__MSG_KEYBOARD_MYANMAR_MYANSAN__", IDS_IME_NAME_KEYBOARD_MYANMAR_MYANSAN},
 271     {"__MSG_KEYBOARD_MYANMAR__", IDS_IME_NAME_KEYBOARD_MYANMAR},
 272     {"__MSG_KEYBOARD_NEPALI_INSCRIPT__", IDS_IME_NAME_KEYBOARD_NEPALI_INSCRIPT},
 273     {"__MSG_KEYBOARD_NEPALI_PHONETIC__", IDS_IME_NAME_KEYBOARD_NEPALI_PHONETIC},
 274     {"__MSG_KEYBOARD_NETHERLANDS__", IDS_IME_NAME_KEYBOARD_NETHERLANDS},
 275     {"__MSG_KEYBOARD_NORWEGIAN__", IDS_IME_NAME_KEYBOARD_NORWEGIAN},
 276     {"__MSG_KEYBOARD_PERSIAN__", IDS_IME_NAME_KEYBOARD_PERSIAN},
 277     {"__MSG_KEYBOARD_POLISH__", IDS_IME_NAME_KEYBOARD_POLISH},
 278     {"__MSG_KEYBOARD_PORTUGUESE__", IDS_IME_NAME_KEYBOARD_PORTUGUESE},
 279     {"__MSG_KEYBOARD_ROMANIAN_STANDARD__",
 280      IDS_IME_NAME_KEYBOARD_ROMANIAN_STANDARD},
 281     {"__MSG_KEYBOARD_ROMANIAN__", IDS_IME_NAME_KEYBOARD_ROMANIAN},
 282     {"__MSG_KEYBOARD_RUSSIAN_PHONETIC_AATSEEL__",
 283      IDS_IME_NAME_KEYBOARD_RUSSIAN_PHONETIC_AATSEEL},
 284     {"__MSG_KEYBOARD_RUSSIAN_PHONETIC_YAZHERT__",
 285      IDS_IME_NAME_KEYBOARD_RUSSIAN_PHONETIC_YAZHERT},
 286     {"__MSG_KEYBOARD_RUSSIAN_PHONETIC__",
 287      IDS_IME_NAME_KEYBOARD_RUSSIAN_PHONETIC},
 288     {"__MSG_KEYBOARD_RUSSIAN__", IDS_IME_NAME_KEYBOARD_RUSSIAN},
 289     {"__MSG_KEYBOARD_SERBIAN__", IDS_IME_NAME_KEYBOARD_SERBIAN},
 290     {"__MSG_KEYBOARD_SINHALA__", IDS_IME_NAME_KEYBOARD_SINHALA},
 291     {"__MSG_KEYBOARD_SLOVAKIAN__", IDS_IME_NAME_KEYBOARD_SLOVAKIAN},
 292     {"__MSG_KEYBOARD_SLOVENIAN__", IDS_IME_NAME_KEYBOARD_SLOVENIAN},
 293     {"__MSG_KEYBOARD_SORANIKURDISH_AR__",
 294      IDS_IME_NAME_KEYBOARD_SORANIKURDISH_AR},
 295     {"__MSG_KEYBOARD_SORANIKURDISH_EN__",
 296      IDS_IME_NAME_KEYBOARD_SORANIKURDISH_EN},
 297     {"__MSG_KEYBOARD_SPANISH__", IDS_IME_NAME_KEYBOARD_SPANISH},
 298     {"__MSG_KEYBOARD_SWEDISH__", IDS_IME_NAME_KEYBOARD_SWEDISH},
 299     {"__MSG_KEYBOARD_SWISS_FRENCH__", IDS_IME_NAME_KEYBOARD_SWISS_FRENCH},
 300     {"__MSG_KEYBOARD_SWISS__", IDS_IME_NAME_KEYBOARD_SWISS},
 301     {"__MSG_KEYBOARD_TAMIL_INSCRIPT__", IDS_IME_NAME_KEYBOARD_TAMIL_INSCRIPT},
 302     {"__MSG_KEYBOARD_TAMIL_ITRANS__", IDS_IME_NAME_KEYBOARD_TAMIL_ITRANS},
 303     {"__MSG_KEYBOARD_TAMIL_PHONETIC__", IDS_IME_NAME_KEYBOARD_TAMIL_PHONETIC},
 304     {"__MSG_KEYBOARD_TAMIL_TAMIL99__", IDS_IME_NAME_KEYBOARD_TAMIL_TAMIL99},
 305     {"__MSG_KEYBOARD_TAMIL_TYPEWRITER__",
 306      IDS_IME_NAME_KEYBOARD_TAMIL_TYPEWRITER},
 307     {"__MSG_KEYBOARD_TELUGU_PHONETIC__", IDS_IME_NAME_KEYBOARD_TELUGU_PHONETIC},
 308     {"__MSG_KEYBOARD_THAI_KEDMANEE__", IDS_IME_NAME_KEYBOARD_THAI_KEDMANEE},
 309     {"__MSG_KEYBOARD_THAI_PATTACHOTE__", IDS_IME_NAME_KEYBOARD_THAI_PATTACHOTE},
 310     {"__MSG_KEYBOARD_THAI_TIS__", IDS_IME_NAME_KEYBOARD_THAI_TIS},
 311     {"__MSG_KEYBOARD_TURKISH__", IDS_IME_NAME_KEYBOARD_TURKISH},
 312     {"__MSG_KEYBOARD_UKRAINIAN__", IDS_IME_NAME_KEYBOARD_UKRAINIAN},
 313     {"__MSG_KEYBOARD_UK_DVORAK__", IDS_IME_NAME_KEYBOARD_UK_DVORAK},
 314     {"__MSG_KEYBOARD_UK__", IDS_IME_NAME_KEYBOARD_UK},
 315     {"__MSG_KEYBOARD_US_COLEMAK__", IDS_IME_NAME_KEYBOARD_US_COLEMAK},
 316     {"__MSG_KEYBOARD_US_DVORAK__", IDS_IME_NAME_KEYBOARD_US_DVORAK},
 317     {"__MSG_KEYBOARD_US_DVP__", IDS_IME_NAME_KEYBOARD_US_DVP},
 318     {"__MSG_KEYBOARD_US_EXTENDED__", IDS_IME_NAME_KEYBOARD_US_EXTENDED},
 319     {"__MSG_KEYBOARD_US_INTERNATIONAL__",
 320      IDS_IME_NAME_KEYBOARD_US_INTERNATIONAL},
 321     {"__MSG_KEYBOARD_US__", IDS_IME_NAME_KEYBOARD_US},
 322     {"__MSG_KEYBOARD_VIETNAMESE_TCVN__", IDS_IME_NAME_KEYBOARD_VIETNAMESE_TCVN},
 323     {"__MSG_KEYBOARD_VIETNAMESE_TELEX__",
 324      IDS_IME_NAME_KEYBOARD_VIETNAMESE_TELEX},
 325     {"__MSG_KEYBOARD_VIETNAMESE_VIQR__", IDS_IME_NAME_KEYBOARD_VIETNAMESE_VIQR},
 326     {"__MSG_KEYBOARD_VIETNAMESE_VNI__", IDS_IME_NAME_KEYBOARD_VIETNAMESE_VNI},
 327     {"__MSG_TRANSLITERATION_AM__", IDS_IME_NAME_TRANSLITERATION_AM},
 328     {"__MSG_TRANSLITERATION_AR__", IDS_IME_NAME_TRANSLITERATION_AR},
 329     {"__MSG_TRANSLITERATION_BN__", IDS_IME_NAME_TRANSLITERATION_BN},
 330     {"__MSG_TRANSLITERATION_EL__", IDS_IME_NAME_TRANSLITERATION_EL},
 331     {"__MSG_TRANSLITERATION_FA__", IDS_IME_NAME_TRANSLITERATION_FA},
 332     {"__MSG_TRANSLITERATION_GU__", IDS_IME_NAME_TRANSLITERATION_GU},
 333     {"__MSG_TRANSLITERATION_HE__", IDS_IME_NAME_TRANSLITERATION_HE},
 334     {"__MSG_TRANSLITERATION_HI__", IDS_IME_NAME_TRANSLITERATION_HI},
 335     {"__MSG_TRANSLITERATION_KN__", IDS_IME_NAME_TRANSLITERATION_KN},
 336     {"__MSG_TRANSLITERATION_ML__", IDS_IME_NAME_TRANSLITERATION_ML},
 337     {"__MSG_TRANSLITERATION_MR__", IDS_IME_NAME_TRANSLITERATION_MR},
 338     {"__MSG_TRANSLITERATION_NE__", IDS_IME_NAME_TRANSLITERATION_NE},
 339     {"__MSG_TRANSLITERATION_OR__", IDS_IME_NAME_TRANSLITERATION_OR},
 340     {"__MSG_TRANSLITERATION_PA__", IDS_IME_NAME_TRANSLITERATION_PA},
 341     {"__MSG_TRANSLITERATION_SA__", IDS_IME_NAME_TRANSLITERATION_SA},
 342     {"__MSG_TRANSLITERATION_SR__", IDS_IME_NAME_TRANSLITERATION_SR},
 343     {"__MSG_TRANSLITERATION_TA__", IDS_IME_NAME_TRANSLITERATION_TA},
 344     {"__MSG_TRANSLITERATION_TE__", IDS_IME_NAME_TRANSLITERATION_TE},
 345     {"__MSG_TRANSLITERATION_TI__", IDS_IME_NAME_TRANSLITERATION_TI},
 346     {"__MSG_TRANSLITERATION_UR__", IDS_IME_NAME_TRANSLITERATION_UR},
 347 };
 348
 349 }  // namespace
 350
 351 namespace chromeos {
 352
 353 namespace input_method {
 354
 355 InputMethodUtil::InputMethodUtil(InputMethodDelegate* delegate)
 356     : delegate_(delegate) {
 357   InputMethodDescriptors default_input_methods;
 358   default_input_methods.push_back(GetFallbackInputMethodDescriptor());
 359   ResetInputMethods(default_input_methods);
 360
 361   // Initialize a map from English string to Chrome string resource ID as well.
 362   for (size_t i = 0; i < kEnglishToResourceIdArraySize; ++i) {
 363     const EnglishToResouceId& map_entry = kEnglishToResourceIdArray[i];
 364     const bool result = english_to_resource_id_.insert(std::make_pair(
 365         map_entry.english_string_from_ibus, map_entry.resource_id)).second;
 366     DCHECK(result) << "Duplicated string is found: "
 367                    << map_entry.english_string_from_ibus;
 368   }
 369 }
 370
 371 InputMethodUtil::~InputMethodUtil() {
 372 }
 373
 374 std::string InputMethodUtil::GetLocalizedDisplayName(
 375     const InputMethodDescriptor& descriptor) const {
 376   // Localizes the input method name.
 377   const std::string& disp = descriptor.name();
 378   if (disp.find("__MSG_") == 0) {
 379     const InputMethodNameMap* map = kInputMethodNameMap;
 380     size_t map_size = arraysize(kInputMethodNameMap);
 381     std::string name = base::StringToUpperASCII(disp);
 382     const InputMethodNameMap map_key = {name.c_str(), 0};
 383     const InputMethodNameMap* p =
 384         std::lower_bound(map, map + map_size, map_key);
 385     if (p != map + map_size && name == p->message_name)
 386       return l10n_util::GetStringUTF8(p->resource_id);
 387   }
 388   return disp;
 389 }
 390
 391 bool InputMethodUtil::TranslateStringInternal(
 392     const std::string& english_string, base::string16 *out_string) const {
 393   DCHECK(out_string);
 394   // |english_string| could be an input method id. So legacy xkb id is required
 395   // to get the translated string.
 396   std::string key_string = extension_ime_util::MaybeGetLegacyXkbId(
 397       english_string);
 398   HashType::const_iterator iter = english_to_resource_id_.find(key_string);
 399
 400   if (iter == english_to_resource_id_.end()) {
 401     // TODO(yusukes): Write Autotest which checks if all display names and all
 402     // property names for supported input methods are listed in the resource
 403     // ID array (crosbug.com/4572).
 404     LOG(ERROR) << "Resource ID is not found for: " << english_string
 405                << ", " << key_string;
 406     return false;
 407   }
 408
 409   *out_string = delegate_->GetLocalizedString(iter->second);
 410   return true;
 411 }
 412
 413 base::string16 InputMethodUtil::TranslateString(
 414     const std::string& english_string) const {
 415   base::string16 localized_string;
 416   if (TranslateStringInternal(english_string, &localized_string)) {
 417     return localized_string;
 418   }
 419   return base::UTF8ToUTF16(english_string);
 420 }
 421
 422 bool InputMethodUtil::IsValidInputMethodId(
 423     const std::string& input_method_id) const {
 424   // We can't check the component extension is whilelisted or not here because
 425   // it might not be initialized.
 426   return GetInputMethodDescriptorFromId(input_method_id) != NULL ||
 427       extension_ime_util::IsComponentExtensionIME(input_method_id);
 428 }
 429
 430 // static
 431 bool InputMethodUtil::IsKeyboardLayout(const std::string& input_method_id) {
 432   return base::StartsWithASCII(input_method_id, "xkb:", false) ||
 433          extension_ime_util::IsKeyboardLayoutExtension(input_method_id);
 434 }
 435
 436 std::string InputMethodUtil::GetKeyboardLayoutName(
 437     const std::string& input_method_id) const {
 438   InputMethodIdToDescriptorMap::const_iterator iter
 439       = id_to_descriptor_.find(input_method_id);
 440   return (iter == id_to_descriptor_.end()) ?
 441       "" : iter->second.GetPreferredKeyboardLayout();
 442 }
 443
 444 std::string InputMethodUtil::GetInputMethodDisplayNameFromId(
 445     const std::string& input_method_id) const {
 446   base::string16 display_name;
 447   if (!extension_ime_util::IsExtensionIME(input_method_id) &&
 448       TranslateStringInternal(input_method_id, &display_name)) {
 449     return base::UTF16ToUTF8(display_name);
 450   }
 451   const InputMethodDescriptor* descriptor =
 452       GetInputMethodDescriptorFromId(input_method_id);
 453   if (descriptor)
 454     return GetLocalizedDisplayName(*descriptor);
 455   // Return an empty string if the input method is not found.
 456   return "";
 457 }
 458
 459 base::string16 InputMethodUtil::GetInputMethodShortName(
 460     const InputMethodDescriptor& input_method) const {
 461   // TODO(shuchen): remove this method, as the client can directly use
 462   // input_method.GetIndicator().
 463   return base::UTF8ToUTF16(input_method.GetIndicator());
 464 }
 465
 466 base::string16 InputMethodUtil::GetInputMethodMediumName(
 467     const InputMethodDescriptor& input_method) const {
 468   // For the "Your input method has changed to..." bubble. In most cases
 469   // it uses the same name as the short name, unless found in a table
 470   // for medium length names.
 471   for (size_t i = 0; i < kMappingImeIdToMediumLenNameResourceIdLen; ++i) {
 472     if (extension_ime_util::GetInputMethodIDByEngineID(
 473         kMappingImeIdToMediumLenNameResourceId[i].engine_id) ==
 474         input_method.id()) {
 475       return delegate_->GetLocalizedString(
 476           kMappingImeIdToMediumLenNameResourceId[i].resource_id);
 477     }
 478   }
 479   return GetInputMethodShortName(input_method);
 480 }
 481
 482 base::string16 InputMethodUtil::GetInputMethodLongNameInternal(
 483     const InputMethodDescriptor& input_method, bool short_name) const {
 484   std::string localized_display_name = GetLocalizedDisplayName(input_method);
 485   if (!localized_display_name.empty() && !IsKeyboardLayout(input_method.id())) {
 486     // If the descriptor has a name, use it.
 487     return base::UTF8ToUTF16(localized_display_name);
 488   }
 489
 490   // We don't show language here.  Name of keyboard layout or input method
 491   // usually imply (or explicitly include) its language.
 492   // Special case for German, French and Dutch: these languages have multiple
 493   // keyboard layouts and share the same layout of keyboard (Belgian). We need
 494   // to show explicitly the language for the layout.
 495   DCHECK(!input_method.language_codes().empty());
 496   const std::string language_code = input_method.language_codes().at(0);
 497
 498   base::string16 text = (short_name || localized_display_name.empty())
 499                             ? TranslateString(input_method.id())
 500                             : base::UTF8ToUTF16(localized_display_name);
 501   if (language_code == "de" || language_code == "fr" || language_code == "nl") {
 502     const base::string16 language_name = delegate_->GetDisplayLanguageName(
 503         language_code);
 504     text = language_name + base::UTF8ToUTF16(" - ") + text;
 505   }
 506
 507   DCHECK(!text.empty());
 508   return text;
 509 }
 510
 511
 512 base::string16 InputMethodUtil::GetInputMethodLongNameStripped(
 513     const InputMethodDescriptor& input_method) const {
 514   return GetInputMethodLongNameInternal(input_method, true /* short_name */);
 515 }
 516
 517 base::string16 InputMethodUtil::GetInputMethodLongName(
 518     const InputMethodDescriptor& input_method) const {
 519   return GetInputMethodLongNameInternal(input_method, false /* short_name */);
 520 }
 521
 522 const InputMethodDescriptor* InputMethodUtil::GetInputMethodDescriptorFromId(
 523     const std::string& input_method_id) const {
 524   InputMethodIdToDescriptorMap::const_iterator iter =
 525       id_to_descriptor_.find(input_method_id);
 526   if (iter == id_to_descriptor_.end())
 527     return NULL;
 528   return &(iter->second);
 529 }
 530
 531 bool InputMethodUtil::GetInputMethodIdsFromLanguageCode(
 532     const std::string& normalized_language_code,
 533     InputMethodType type,
 534     std::vector<std::string>* out_input_method_ids) const {
 535   return GetInputMethodIdsFromLanguageCodeInternal(
 536       language_code_to_ids_,
 537       normalized_language_code, type, out_input_method_ids);
 538 }
 539
 540 bool InputMethodUtil::GetInputMethodIdsFromLanguageCodeInternal(
 541     const std::multimap<std::string, std::string>& language_code_to_ids,
 542     const std::string& normalized_language_code,
 543     InputMethodType type,
 544     std::vector<std::string>* out_input_method_ids) const {
 545   DCHECK(out_input_method_ids);
 546   out_input_method_ids->clear();
 547
 548   bool result = false;
 549   std::pair<LanguageCodeToIdsMap::const_iterator,
 550       LanguageCodeToIdsMap::const_iterator> range =
 551       language_code_to_ids.equal_range(normalized_language_code);
 552   for (LanguageCodeToIdsMap::const_iterator iter = range.first;
 553        iter != range.second; ++iter) {
 554     const std::string& input_method_id = iter->second;
 555     if ((type == kAllInputMethods) || IsKeyboardLayout(input_method_id)) {
 556       out_input_method_ids->push_back(input_method_id);
 557       result = true;
 558     }
 559   }
 560   if ((type == kAllInputMethods) && !result) {
 561     DVLOG(1) << "Unknown language code: " << normalized_language_code;
 562   }
 563   return result;
 564 }
 565
 566 void InputMethodUtil::GetFirstLoginInputMethodIds(
 567     const std::string& language_code,
 568     const InputMethodDescriptor& current_input_method,
 569     std::vector<std::string>* out_input_method_ids) const {
 570   out_input_method_ids->clear();
 571
 572   // First, add the current keyboard layout (one used on the login screen).
 573   out_input_method_ids->push_back(current_input_method.id());
 574
 575   const std::string current_layout
 576       = current_input_method.GetPreferredKeyboardLayout();
 577   for (size_t i = 0; i < arraysize(kDefaultInputMethodRecommendation);
 578        ++i) {
 579     if (kDefaultInputMethodRecommendation[i].locale == language_code && (
 580         !kDefaultInputMethodRecommendation[i].layout[0] ||
 581         kDefaultInputMethodRecommendation[i].layout == current_layout)) {
 582       out_input_method_ids->push_back(
 583           extension_ime_util::GetInputMethodIDByEngineID(
 584               kDefaultInputMethodRecommendation[i].engine_id));
 585       return;
 586     }
 587   }
 588
 589   std::vector<std::string> input_method_ids;
 590   GetInputMethodIdsFromLanguageCode(
 591       language_code, kAllInputMethods, &input_method_ids);
 592   // Uses the first input method as the most popular one.
 593   if (input_method_ids.size() > 0 &&
 594       current_input_method.id() != input_method_ids[0]) {
 595     out_input_method_ids->push_back(input_method_ids[0]);
 596   }
 597 }
 598
 599 void InputMethodUtil::GetLanguageCodesFromInputMethodIds(
 600     const std::vector<std::string>& input_method_ids,
 601     std::vector<std::string>* out_language_codes) const {
 602   out_language_codes->clear();
 603
 604   for (size_t i = 0; i < input_method_ids.size(); ++i) {
 605     const std::string& input_method_id = input_method_ids[i];
 606     const InputMethodDescriptor* input_method =
 607         GetInputMethodDescriptorFromId(input_method_id);
 608     if (!input_method) {
 609       DVLOG(1) << "Unknown input method ID: " << input_method_ids[i];
 610       continue;
 611     }
 612     DCHECK(!input_method->language_codes().empty());
 613     const std::string language_code = input_method->language_codes().at(0);
 614     // Add it if it's not already present.
 615     if (std::count(out_language_codes->begin(), out_language_codes->end(),
 616                    language_code) == 0) {
 617       out_language_codes->push_back(language_code);
 618     }
 619   }
 620 }
 621
 622 std::string InputMethodUtil::GetLanguageDefaultInputMethodId(
 623     const std::string& language_code) {
 624   std::vector<std::string> candidates;
 625   GetInputMethodIdsFromLanguageCode(
 626       language_code, input_method::kKeyboardLayoutsOnly, &candidates);
 627   if (candidates.size())
 628     return candidates.front();
 629
 630   return std::string();
 631 }
 632
 633 std::string InputMethodUtil::MigrateInputMethod(
 634     const std::string& input_method_id) {
 635   std::string engine_id = input_method_id;
 636   // Migrates some Engine IDs from VPD.
 637   for (size_t j = 0; j < arraysize(kEngineIdMigrationMap); ++j) {
 638     size_t pos = engine_id.find(kEngineIdMigrationMap[j][0]);
 639     if (pos == 0) {
 640       engine_id.replace(0,
 641                         strlen(kEngineIdMigrationMap[j][0]),
 642                         kEngineIdMigrationMap[j][1]);
 643       break;
 644     }
 645   }
 646   // Migrates the extension IDs.
 647   std::string id =
 648       extension_ime_util::GetInputMethodIDByEngineID(engine_id);
 649   if (extension_ime_util::IsComponentExtensionIME(id)) {
 650     std::string id_new = extension_ime_util::GetInputMethodIDByEngineID(
 651         extension_ime_util::GetComponentIDByInputMethodID(id));
 652     if (extension_ime_util::IsComponentExtensionIME(id_new))
 653       id = id_new;
 654   }
 655   return id;
 656 }
 657
 658 bool InputMethodUtil::MigrateInputMethods(
 659     std::vector<std::string>* input_method_ids) {
 660   bool rewritten = false;
 661   std::vector<std::string>& ids = *input_method_ids;
 662   for (size_t i = 0; i < ids.size(); ++i) {
 663     std::string id = MigrateInputMethod(ids[i]);
 664     if (id != ids[i]) {
 665       ids[i] = id;
 666       rewritten = true;
 667     }
 668   }
 669   if (rewritten) {
 670     // Removes the duplicates.
 671     std::vector<std::string> new_ids;
 672     for (size_t i = 0; i < ids.size(); ++i) {
 673       if (std::find(new_ids.begin(), new_ids.end(), ids[i]) == new_ids.end())
 674         new_ids.push_back(ids[i]);
 675     }
 676     ids.swap(new_ids);
 677   }
 678   return rewritten;
 679 }
 680
 681 void InputMethodUtil::UpdateHardwareLayoutCache() {
 682   DCHECK(thread_checker_.CalledOnValidThread());
 683   hardware_layouts_.clear();
 684   hardware_login_layouts_.clear();
 685   if (cached_hardware_layouts_.empty())
 686     Tokenize(delegate_->GetHardwareKeyboardLayouts(), ",",
 687              &cached_hardware_layouts_);
 688   hardware_layouts_ = cached_hardware_layouts_;
 689   MigrateInputMethods(&hardware_layouts_);
 690
 691   for (size_t i = 0; i < hardware_layouts_.size(); ++i) {
 692     if (IsLoginKeyboard(hardware_layouts_[i]))
 693       hardware_login_layouts_.push_back(hardware_layouts_[i]);
 694   }
 695
 696   if (hardware_login_layouts_.empty()) {
 697     // This is totally fine if |hardware_layouts_| is empty. The hardware
 698     // keyboard layout is not stored if startup_manifest.json
 699     // (OEM customization data) is not present (ex. Cr48 doen't have that file).
 700     // So need to make sure |hardware_login_layouts_| is not empty, and
 701     // |hardware_layouts_| contains at least one login layout.
 702     std::string fallback_id = GetFallbackInputMethodDescriptor().id();
 703     hardware_layouts_.insert(hardware_layouts_.begin(), fallback_id);
 704     hardware_login_layouts_.push_back(fallback_id);
 705   }
 706 }
 707
 708 void InputMethodUtil::SetHardwareKeyboardLayoutForTesting(
 709     const std::string& layout) {
 710   delegate_->SetHardwareKeyboardLayoutForTesting(layout);
 711   cached_hardware_layouts_.clear();
 712   UpdateHardwareLayoutCache();
 713 }
 714
 715 const std::vector<std::string>&
 716     InputMethodUtil::GetHardwareInputMethodIds() {
 717   DCHECK(thread_checker_.CalledOnValidThread());
 718   UpdateHardwareLayoutCache();
 719   return hardware_layouts_;
 720 }
 721
 722 const std::vector<std::string>&
 723     InputMethodUtil::GetHardwareLoginInputMethodIds() {
 724   DCHECK(thread_checker_.CalledOnValidThread());
 725   UpdateHardwareLayoutCache();
 726   return hardware_login_layouts_;
 727 }
 728
 729 bool InputMethodUtil::IsLoginKeyboard(const std::string& input_method_id)
 730     const {
 731   const InputMethodDescriptor* ime =
 732       GetInputMethodDescriptorFromId(input_method_id);
 733   return ime ? ime->is_login_keyboard() : false;
 734 }
 735
 736 void InputMethodUtil::AppendInputMethods(const InputMethodDescriptors& imes) {
 737   for (size_t i = 0; i < imes.size(); ++i) {
 738     const InputMethodDescriptor& input_method = imes[i];
 739     DCHECK(!input_method.language_codes().empty());
 740     const std::vector<std::string>& language_codes =
 741         input_method.language_codes();
 742     id_to_descriptor_[input_method.id()] = input_method;
 743
 744     typedef LanguageCodeToIdsMap::const_iterator It;
 745     for (size_t j = 0; j < language_codes.size(); ++j) {
 746       std::pair<It, It> range =
 747           language_code_to_ids_.equal_range(language_codes[j]);
 748       It it = range.first;
 749       for (; it != range.second; ++it) {
 750         if (it->second == input_method.id())
 751           break;
 752       }
 753       if (it == range.second)
 754         language_code_to_ids_.insert(
 755             std::make_pair(language_codes[j], input_method.id()));
 756     }
 757   }
 758 }
 759
 760 void InputMethodUtil::ResetInputMethods(const InputMethodDescriptors& imes) {
 761   // Clear the existing maps.
 762   language_code_to_ids_.clear();
 763   id_to_descriptor_.clear();
 764
 765   AppendInputMethods(imes);
 766 }
 767
 768 void InputMethodUtil::InitXkbInputMethodsForTesting() {
 769   cached_hardware_layouts_.clear();
 770   ResetInputMethods(*(InputMethodWhitelist().GetSupportedInputMethods()));
 771 }
 772
 773 const InputMethodUtil::InputMethodIdToDescriptorMap&
 774 InputMethodUtil::GetIdToDesciptorMapForTesting() {
 775   return id_to_descriptor_;
 776 }
 777
 778 InputMethodDescriptor InputMethodUtil::GetFallbackInputMethodDescriptor() {
 779   std::vector<std::string> layouts;
 780   layouts.push_back("us");
 781   std::vector<std::string> languages;
 782   languages.push_back("en-US");
 783   return InputMethodDescriptor(
 784       extension_ime_util::GetInputMethodIDByEngineID("xkb:us::eng"),
 785       "",
 786       "US",
 787       layouts,
 788       languages,
 789       true,  // login keyboard.
 790       GURL(),  // options page, not available.
 791       GURL()); // input view page, not available.
 792 }
 793
 794 }  // namespace input_method
 795 }  // namespace chromeos