#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 "chromeos/ime/component_extension_ime_manager.h"
#include "chromeos/ime/extension_ime_util.h"
+// For SetHardwareKeyboardLayoutForTesting.
+#include "chromeos/ime/fake_input_method_delegate.h"
#include "chromeos/ime/input_method_delegate.h"
-// TODO(nona): move this header from this file.
-#include "grit/generated_resources.h"
+#include "chromeos/ime/input_method_whitelist.h"
namespace {
// 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* engine_id;
const char* indicator_text;
} kMappingFromIdToIndicatorText[] = {
- // To distinguish from "xkb:us::eng"
- { "xkb:us:altgr-intl:eng", "EXTD" },
- { "xkb:us:dvorak:eng", "DV" },
- { "xkb:us:intl:eng", "INTL" },
- { "xkb:us:colemak:eng", "CO" },
- { "english-m", "??" },
- { "xkb:de:neo:ger", "NEO" },
- // To distinguish from "xkb:es::spa"
- { "xkb:es:cat:cat", "CAS" },
- // To distinguish from "xkb:gb::eng"
- { "xkb:gb:dvorak:eng", "DV" },
// To distinguish from "xkb:jp::jpn"
// TODO(nona): Make following variables configurable. http://crbug.com/232260.
- { "_comp_ime_fpfbhcjppmaeaijcidgiibchfbnhbeljnacl_mozc_us", "\xe3\x81\x82" },
- { "_comp_ime_fpfbhcjppmaeaijcidgiibchfbnhbeljnacl_mozc_jp", "\xe3\x81\x82" },
- { "_comp_ime_bbaiamgfapehflhememkfglaehiobjnknacl_mozc_us", "\xe3\x81\x82" },
- { "_comp_ime_bbaiamgfapehflhememkfglaehiobjnknacl_mozc_jp", "\xe3\x81\x82" },
+ { "nacl_mozc_us", "\xe3\x81\x82" },
+ { "nacl_mozc_jp", "\xe3\x81\x82" },
// For simplified Chinese input methods
- { "pinyin", "\xe6\x8b\xbc" }, // U+62FC
- { "_comp_ime_cpgalbafkoofkjmaeonnfijgpfennjjnzh-t-i0-pinyin",
- "\xe6\x8b\xbc" },
- { "_comp_ime_nmblnjkfdkabgdofidlkienfnnbjhnabzh-t-i0-pinyin",
- "\xe6\x8b\xbc" },
- { "_comp_ime_gjhclobljhjhgoebiipblnmdodbmpdgdzh-t-i0-wubi-1986",
- "\xe4\xba\x94" }, // U+4E94
- { "pinyin-dv", "\xe6\x8b\xbc" },
+ { "zh-t-i0-pinyin", "\xe6\x8b\xbc" }, // U+62FC
+ { "zh-t-i0-wubi-1986", "\xe4\xba\x94" }, // U+4E94
// For traditional Chinese input methods
- { "mozc-chewing", "\xe9\x85\xb7" }, // U+9177
- { "_comp_ime_ekbifjdfhkmdeeajnolmgdlmkllopefizh-hant-t-i0-und",
- "\xE6\xB3\xA8" }, // U+6CE8
- { "_comp_ime_goedamlknlnjaengojinmfgpmdjmkooozh-hant-t-i0-und",
- "\xE6\xB3\xA8" }, // U+6CE8
- { "m17n:zh:cangjie", "\xe5\x80\x89" }, // U+5009
- { "_comp_ime_aeebooiibjahgpgmhkeocbeekccfknbjzh-hant-t-i0-cangjie-1987",
- "\xe5\x80\x89" }, // U+5009
- { "_comp_ime_gjhclobljhjhgoebiipblnmdodbmpdgdzh-hant-t-i0-cangjie-1987",
- "\xe5\x80\x89" }, // U+5009
- { "m17n:zh:quick", "\xe9\x80\x9f" }, // U+901F
+ { "zh-hant-t-i0-und", "\xE6\xB3\xA8" }, // U+9177
+ { "zh-hant-t-i0-cangjie-1987", "\xe5\x80\x89" }, // U+5009
+ { "zh-hant-t-i0-cangjie-1987-x-m0-simplified", "\xe9\x80\x9f" }, // U+901F
// For Hangul input method.
- { "mozc-hangul", "\xed\x95\x9c" }, // U+D55C
- { "_comp_ime_bdgdidmhaijohebebipajioienkglgfohangul_2set", "\xed\x95\x9c" },
- { "_comp_ime_bdgdidmhaijohebebipajioienkglgfohangul_3set390",
- "\xed\x95\x9c" },
- { "_comp_ime_bdgdidmhaijohebebipajioienkglgfohangul_3setfinal",
- "\xed\x95\x9c" },
- { "_comp_ime_bdgdidmhaijohebebipajioienkglgfohangul_3setnoshift",
- "\xed\x95\x9c" },
- { "_comp_ime_bdgdidmhaijohebebipajioienkglgfohangul_romaja", "\xed\x95\x9c" },
+ { "hangul_2set", "\xed\x95\x9c" }, // U+D55C
+ { "hangul_3set390", "\xed\x95\x9c" }, // U+D55C
+ { "hangul_3setfinal", "\xed\x95\x9c" }, // U+D55C
+ { "hangul_3setnoshift", "\xed\x95\x9c" }, // U+D55C
+ { "hangul_romaja", "\xed\x95\x9c" }, // U+D55C
+ { extension_misc::kBrailleImeEngineId,
+ // U+2803 U+2817 U+2807 (Unicode braille patterns for the letters 'brl' in
+ // English (and many other) braille codes.
+ "\xe2\xa0\x83\xe2\xa0\x97\xe2\xa0\x87" },
};
const size_t kMappingFromIdToIndicatorTextLen =
// "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* input_method_id;
+ const char* engine_id;
const int resource_id;
} kMappingImeIdToMediumLenNameResourceId[] = {
- { "m17n:zh:cangjie", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL },
- { "m17n:zh:quick", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL },
- { "mozc-chewing", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL },
- { "mozc-hangul", IDS_LANGUAGES_MEDIUM_LEN_NAME_KOREAN },
- { "pinyin", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_SIMPLIFIED },
- { "pinyin-dv", IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_SIMPLIFIED },
- { "_comp_ime_cpgalbafkoofkjmaeonnfijgpfennjjnzh-t-i0-pinyin",
- IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_SIMPLIFIED},
- { "_comp_ime_nmblnjkfdkabgdofidlkienfnnbjhnabzh-t-i0-pinyin",
- IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_SIMPLIFIED },
- { "_comp_ime_gjhclobljhjhgoebiipblnmdodbmpdgdzh-t-i0-wubi-1986",
- IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_SIMPLIFIED },
- { "_comp_ime_ekbifjdfhkmdeeajnolmgdlmkllopefizh-hant-t-i0-und",
- IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL },
- { "_comp_ime_goedamlknlnjaengojinmfgpmdjmkooozh-hant-t-i0-und",
+ { "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 },
- { "_comp_ime_aeebooiibjahgpgmhkeocbeekccfknbjzh-hant-t-i0-cangjie-1987",
- IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL },
- { "_comp_ime_gjhclobljhjhgoebiipblnmdodbmpdgdzh-hant-t-i0-cangjie-1987",
+ { "zh-hant-t-i0-cangjie-1987-x-m0-simplified",
IDS_LANGUAGES_MEDIUM_LEN_NAME_CHINESE_TRADITIONAL },
+ { extension_misc::kBrailleImeEngineId,
+ IDS_LANGUAGES_MEDIUM_LEN_NAME_BRAILLE },
};
const size_t kMappingImeIdToMediumLenNameResourceIdLen =
ARRAYSIZE_UNSAFE(kMappingImeIdToMediumLenNameResourceId);
const struct {
const char* locale;
const char* layout;
- const char* input_method_id;
+ const char* engine_id;
} kDefaultInputMethodRecommendation[] = {
- { "ja", "us", "_comp_ime_fpfbhcjppmaeaijcidgiibchfbnhbeljnacl_mozc_us" },
- { "ja", "jp", "_comp_ime_fpfbhcjppmaeaijcidgiibchfbnhbeljnacl_mozc_jp" },
- { "zh-CN", "us", "_comp_ime_nmblnjkfdkabgdofidlkienfnnbjhnabzh-t-i0-pinyin" },
- { "zh-TW", "us",
- "_comp_ime_goedamlknlnjaengojinmfgpmdjmkooozh-hant-t-i0-und" },
- { "th", "us", "_comp_ime_jhffeifommiaekmbkkjlpmilogcfdohpvkd_th" },
- { "vi", "us", "_comp_ime_jhffeifommiaekmbkkjlpmilogcfdohpvkd_vi_tcvn" },
- { "vi", "us", "_comp_ime_jhffeifommiaekmbkkjlpmilogcfdohpvkd_vi_tcvn" },
+ { "ja", "us", "nacl_mozc_us" },
+ { "ja", "jp", "nacl_mozc_jp" },
+ { "zh-CN", "us", "zh-t-i0-pinyin" },
+ { "zh-TW", "us", "zh-hant-t-i0-und" },
+ { "th", "us", "vkd_th" },
+ { "vi", "us", "vkd_vi_tcvn" },
};
-} // namespace
-
-namespace chromeos {
-
-extern const char* kExtensionImePrefix;
+// The map from xkb layout to the indicator text.
+// Refer to crbug.com/349829.
+const char* const kXkbIndicators[][2] = {{"am", "AM"},
+ {"be", "BE"},
+ {"bg", "BG"},
+ {"bg(phonetic)", "BG"},
+ {"br", "BR"},
+ {"by", "BY"},
+ {"ca", "CA"},
+ {"ca(eng)", "CA"},
+ {"ca(multix)", "CA"},
+ {"ch", "CH"},
+ {"ch(fr)", "CH"},
+ {"cz", "CZ"},
+ {"cz(qwerty)", "CS"},
+ {"de", "DE"},
+ {"de(neo)", "NEO"},
+ {"dk", "DK"},
+ {"ee", "EE"},
+ {"es", "ES"},
+ {"es(cat)", "CAS"},
+ {"fi", "FI"},
+ {"fr", "FR"},
+ {"gb(dvorak)", "DV"},
+ {"gb(extd)", "GB"},
+ {"ge", "GE"},
+ {"gr", "GR"},
+ {"hr", "HR"},
+ {"hu", "HU"},
+ {"il", "IL"},
+ {"is", "IS"},
+ {"it", "IT"},
+ {"jp", "JA"},
+ {"latam", "LA"},
+ {"lt", "LT"},
+ {"lv(apostrophe)", "LV"},
+ {"mn", "MN"},
+ {"no", "NO"},
+ {"pl", "PL"},
+ {"pt", "PT"},
+ {"ro", "RO"},
+ {"rs", "RS"},
+ {"ru", "RU"},
+ {"ru(phonetic)", "RU"},
+ {"se", "SE"},
+ {"si", "SI"},
+ {"sk", "SK"},
+ {"tr", "TR"},
+ {"ua", "UA"},
+ {"us", "US"},
+ {"us(altgr-intl)", "EXTD"},
+ {"us(colemak)", "CO"},
+ {"us(dvorak)", "DV"},
+ {"us(intl)", "INTL"}, };
+
+// The extension ID map for migration.
+const char* const kExtensionIdMigrationMap[][2] = {
+ // Official Japanese IME extension ID.
+ {"fpfbhcjppmaeaijcidgiibchfbnhbelj", "gjaehgfemfahhmlgpdfknkhdnemmolop"},
+ // Official M17n keyboard extension ID.
+ {"habcdindjejkmepknlhkkloncjcpcnbf", "gjaehgfemfahhmlgpdfknkhdnemmolop"},
+};
-namespace input_method {
+// The engine ID map for migration. This migration is for input method IDs from
+// VPD so it's NOT a temporary migration.
+const char* const kEngineIdMigrationMap[][2] = {
+ {"m17n:", "vkd_"},
+ {"ime:zh-t:quick", "zh-hant-t-i0-cangjie-1987-x-m0-simplified"},
+ {"ime:zh-t:zhuyin", "zh-hant-t-i0-und"},
+ {"ime:ko:hangul", "hangul_2set"},
+ {"ime:ko:hangul_2set", "hangul_2set"},
+};
-namespace {
+const size_t kExtensionIdLen = 32;
const struct EnglishToResouceId {
const char* english_string_from_ibus;
int resource_id;
} kEnglishToResourceIdArray[] = {
- // For ibus-mozc-hangul
- { "Hanja mode", IDS_STATUSBAR_IME_KOREAN_HANJA_INPUT_MODE },
- { "Hangul mode", IDS_STATUSBAR_IME_KOREAN_HANGUL_INPUT_MODE },
-
- // For ibus-mozc-pinyin.
- { "Full/Half width",
- IDS_STATUSBAR_IME_CHINESE_PINYIN_TOGGLE_FULL_HALF },
- { "Full/Half width punctuation",
- IDS_STATUSBAR_IME_CHINESE_PINYIN_TOGGLE_FULL_HALF_PUNCTUATION },
- // TODO(hsumita): Fixes a typo
- { "Simplfied/Traditional Chinese",
- IDS_STATUSBAR_IME_CHINESE_PINYIN_TOGGLE_S_T_CHINESE },
- { "Chinese",
- IDS_STATUSBAR_IME_CHINESE_PINYIN_TOGGLE_CHINESE_ENGLISH },
-
- // For ibus-mozc-chewing.
- { "English",
- IDS_STATUSBAR_IME_CHINESE_MOZC_CHEWING_ENGLISH_MODE },
- { "_Chinese",
- IDS_STATUSBAR_IME_CHINESE_MOZC_CHEWING_CHINESE_MODE },
- { "Full-width English",
- IDS_STATUSBAR_IME_CHINESE_MOZC_CHEWING_FULL_WIDTH_ENGLISH_MODE },
-
- // For the "Languages and Input" dialog.
- { "m17n:ar:kbd", IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_STANDARD_INPUT_METHOD },
- { "m17n:hi:itrans", // also uses the "STANDARD_INPUT_METHOD" id.
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_STANDARD_INPUT_METHOD },
- { "m17n:zh:cangjie",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_CHINESE_CANGJIE_INPUT_METHOD },
- { "m17n:zh:quick",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_CHINESE_QUICK_INPUT_METHOD },
- { "m17n:fa:isiri",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_PERSIAN_ISIRI_2901_INPUT_METHOD },
- { "m17n:th:kesmanee",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_THAI_KESMANEE_INPUT_METHOD },
- { "m17n:th:tis820",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_THAI_TIS820_INPUT_METHOD },
- { "m17n:th:pattachote",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_THAI_PATTACHOTE_INPUT_METHOD },
- { "m17n:vi:tcvn",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_VIETNAMESE_TCVN_INPUT_METHOD },
- { "m17n:vi:telex",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_VIETNAMESE_TELEX_INPUT_METHOD },
- { "m17n:vi:viqr",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_VIETNAMESE_VIQR_INPUT_METHOD },
- { "m17n:vi:vni",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_VIETNAMESE_VNI_INPUT_METHOD },
- { "m17n:bn:itrans",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_STANDARD_INPUT_METHOD },
- { "m17n:gu:itrans",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_STANDARD_INPUT_METHOD },
- { "m17n:ml:itrans",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_STANDARD_INPUT_METHOD },
- { "m17n:mr:itrans",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_STANDARD_INPUT_METHOD },
- { "m17n:ta:phonetic",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_TAMIL_PHONETIC },
- { "m17n:ta:inscript",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_TAMIL_INSCRIPT },
- { "m17n:ta:tamil99",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_TAMIL_TAMIL99 },
- { "m17n:ta:itrans",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_TAMIL_ITRANS },
- { "m17n:ta:typewriter",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_TAMIL_TYPEWRITER },
- { "m17n:am:sera",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_STANDARD_INPUT_METHOD },
- { "m17n:te:itrans",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_STANDARD_INPUT_METHOD },
- { "m17n:kn:itrans",
- IDS_OPTIONS_SETTINGS_LANGUAGES_M17N_STANDARD_INPUT_METHOD },
-
- { "mozc-chewing",
- IDS_OPTIONS_SETTINGS_LANGUAGES_CHEWING_INPUT_METHOD },
- { "pinyin", IDS_OPTIONS_SETTINGS_LANGUAGES_PINYIN_INPUT_METHOD },
- { "pinyin-dv",
- IDS_OPTIONS_SETTINGS_LANGUAGES_PINYIN_DV_INPUT_METHOD },
- { "zinnia-japanese",
- IDS_OPTIONS_SETTINGS_LANGUAGES_JAPANESE_HANDWRITING_INPUT_METHOD },
- { "mozc-hangul", IDS_OPTIONS_SETTINGS_LANGUAGES_KOREAN_INPUT_METHOD },
-
- // For ibus-xkb-layouts engine: third_party/ibus-xkb-layouts/files
- { "xkb:jp::jpn", IDS_STATUSBAR_LAYOUT_JAPAN },
- { "xkb:si::slv", IDS_STATUSBAR_LAYOUT_SLOVENIA },
- { "xkb:de::ger", IDS_STATUSBAR_LAYOUT_GERMANY },
- { "xkb:de:neo:ger", IDS_STATUSBAR_LAYOUT_GERMANY_NEO2 },
- { "xkb:it::ita", IDS_STATUSBAR_LAYOUT_ITALY },
- { "xkb:ee::est", IDS_STATUSBAR_LAYOUT_ESTONIA },
- { "xkb:hu::hun", IDS_STATUSBAR_LAYOUT_HUNGARY },
- { "xkb:pl::pol", IDS_STATUSBAR_LAYOUT_POLAND },
- { "xkb:dk::dan", IDS_STATUSBAR_LAYOUT_DENMARK },
- { "xkb:hr::scr", IDS_STATUSBAR_LAYOUT_CROATIA },
- { "xkb:br::por", IDS_STATUSBAR_LAYOUT_BRAZIL },
- { "xkb:rs::srp", IDS_STATUSBAR_LAYOUT_SERBIA },
- { "xkb:cz::cze", IDS_STATUSBAR_LAYOUT_CZECHIA },
- { "xkb:cz:qwerty:cze", IDS_STATUSBAR_LAYOUT_CZECHIA_QWERTY },
- { "xkb:us:dvorak:eng", IDS_STATUSBAR_LAYOUT_USA_DVORAK },
- { "xkb:us:colemak:eng", IDS_STATUSBAR_LAYOUT_USA_COLEMAK },
- { "xkb:ro::rum", IDS_STATUSBAR_LAYOUT_ROMANIA },
- { "xkb:us::eng", IDS_STATUSBAR_LAYOUT_USA },
- { "xkb:us:altgr-intl:eng", IDS_STATUSBAR_LAYOUT_USA_EXTENDED },
- { "xkb:us:intl:eng", IDS_STATUSBAR_LAYOUT_USA_INTERNATIONAL },
- { "xkb:lt::lit", IDS_STATUSBAR_LAYOUT_LITHUANIA },
- { "xkb:gb:extd:eng", IDS_STATUSBAR_LAYOUT_UNITED_KINGDOM },
- { "xkb:gb:dvorak:eng", IDS_STATUSBAR_LAYOUT_UNITED_KINGDOM_DVORAK },
- { "xkb:sk::slo", IDS_STATUSBAR_LAYOUT_SLOVAKIA },
- { "xkb:ru::rus", IDS_STATUSBAR_LAYOUT_RUSSIA },
- { "xkb:ru:phonetic:rus", IDS_STATUSBAR_LAYOUT_RUSSIA_PHONETIC },
- { "xkb:gr::gre", IDS_STATUSBAR_LAYOUT_GREECE },
+ // For xkb-layouts.
+ { "xkb:am:phonetic:arm", IDS_STATUSBAR_LAYOUT_ARMENIAN_PHONETIC },
{ "xkb:be::fra", IDS_STATUSBAR_LAYOUT_BELGIUM },
{ "xkb:be::ger", IDS_STATUSBAR_LAYOUT_BELGIUM },
{ "xkb:be::nld", IDS_STATUSBAR_LAYOUT_BELGIUM },
{ "xkb:bg::bul", IDS_STATUSBAR_LAYOUT_BULGARIA },
{ "xkb:bg:phonetic:bul", IDS_STATUSBAR_LAYOUT_BULGARIA_PHONETIC },
+ { "xkb:br::por", IDS_STATUSBAR_LAYOUT_BRAZIL },
+ { "xkb:by::bel", IDS_STATUSBAR_LAYOUT_BELARUSIAN },
+ { "xkb:ca::fra", IDS_STATUSBAR_LAYOUT_CANADA },
+ { "xkb:ca:eng:eng", IDS_STATUSBAR_LAYOUT_CANADA_ENGLISH },
+ { "xkb:ca:multix:fra", IDS_STATUSBAR_LAYOUT_CANADIAN_MULTILINGUAL },
{ "xkb:ch::ger", IDS_STATUSBAR_LAYOUT_SWITZERLAND },
{ "xkb:ch:fr:fra", IDS_STATUSBAR_LAYOUT_SWITZERLAND_FRENCH },
- { "xkb:tr::tur", IDS_STATUSBAR_LAYOUT_TURKEY },
- { "xkb:pt::por", IDS_STATUSBAR_LAYOUT_PORTUGAL },
+ { "xkb:cz::cze", IDS_STATUSBAR_LAYOUT_CZECHIA },
+ { "xkb:cz:qwerty:cze", IDS_STATUSBAR_LAYOUT_CZECHIA_QWERTY },
+ { "xkb:de::ger", IDS_STATUSBAR_LAYOUT_GERMANY },
+ { "xkb:de:neo:ger", IDS_STATUSBAR_LAYOUT_GERMANY_NEO2 },
+ { "xkb:dk::dan", IDS_STATUSBAR_LAYOUT_DENMARK },
+ { "xkb:ee::est", IDS_STATUSBAR_LAYOUT_ESTONIA },
{ "xkb:es::spa", IDS_STATUSBAR_LAYOUT_SPAIN },
- { "xkb:fi::fin", IDS_STATUSBAR_LAYOUT_FINLAND },
- { "xkb:ua::ukr", IDS_STATUSBAR_LAYOUT_UKRAINE },
{ "xkb:es:cat:cat", IDS_STATUSBAR_LAYOUT_SPAIN_CATALAN },
+ { "xkb:fi::fin", IDS_STATUSBAR_LAYOUT_FINLAND },
{ "xkb:fr::fra", IDS_STATUSBAR_LAYOUT_FRANCE },
- { "xkb:no::nob", IDS_STATUSBAR_LAYOUT_NORWAY },
- { "xkb:se::swe", IDS_STATUSBAR_LAYOUT_SWEDEN },
- { "xkb:nl::nld", IDS_STATUSBAR_LAYOUT_NETHERLANDS },
- { "xkb:latam::spa", IDS_STATUSBAR_LAYOUT_LATIN_AMERICAN },
- { "xkb:lv:apostrophe:lav", IDS_STATUSBAR_LAYOUT_LATVIA },
- { "xkb:ca::fra", IDS_STATUSBAR_LAYOUT_CANADA },
- { "xkb:ca:eng:eng", IDS_STATUSBAR_LAYOUT_CANADA_ENGLISH },
+ { "xkb:gb:dvorak:eng", IDS_STATUSBAR_LAYOUT_UNITED_KINGDOM_DVORAK },
+ { "xkb:gb:extd:eng", IDS_STATUSBAR_LAYOUT_UNITED_KINGDOM },
+ { "xkb:ge::geo", IDS_STATUSBAR_LAYOUT_GEORGIAN },
+ { "xkb:gr::gre", IDS_STATUSBAR_LAYOUT_GREECE },
+ { "xkb:hr::scr", IDS_STATUSBAR_LAYOUT_CROATIA },
+ { "xkb:hu::hun", IDS_STATUSBAR_LAYOUT_HUNGARY },
+ { "xkb:ie::ga", IDS_STATUSBAR_LAYOUT_IRISH },
{ "xkb:il::heb", IDS_STATUSBAR_LAYOUT_ISRAEL },
- { "xkb:kr:kr104:kor", IDS_STATUSBAR_LAYOUT_KOREA_104 },
{ "xkb:is::ice", IDS_STATUSBAR_LAYOUT_ICELANDIC },
- { "xkb:ca:multix:fra", IDS_STATUSBAR_LAYOUT_CANADIAN_MULTILINGUAL },
- { "xkb:by::bel", IDS_STATUSBAR_LAYOUT_BELARUSIAN },
- { "xkb:am:phonetic:arm", IDS_STATUSBAR_LAYOUT_ARMENIAN_PHONETIC },
- { "xkb:ge::geo", IDS_STATUSBAR_LAYOUT_GEORGIAN },
+ { "xkb:it::ita", IDS_STATUSBAR_LAYOUT_ITALY },
+ { "xkb:jp::jpn", IDS_STATUSBAR_LAYOUT_JAPAN },
+ { "xkb:latam::spa", IDS_STATUSBAR_LAYOUT_LATIN_AMERICAN },
+ { "xkb:lt::lit", IDS_STATUSBAR_LAYOUT_LITHUANIA },
+ { "xkb:lv:apostrophe:lav", IDS_STATUSBAR_LAYOUT_LATVIA },
{ "xkb:mn::mon", IDS_STATUSBAR_LAYOUT_MONGOLIAN },
-
- { "english-m", IDS_STATUSBAR_LAYOUT_USA_MYSTERY },
+ { "xkb:nl::nld", IDS_STATUSBAR_LAYOUT_NETHERLANDS },
+ { "xkb:no::nob", IDS_STATUSBAR_LAYOUT_NORWAY },
+ { "xkb:pl::pol", IDS_STATUSBAR_LAYOUT_POLAND },
+ { "xkb:pt::por", IDS_STATUSBAR_LAYOUT_PORTUGAL },
+ { "xkb:ro::rum", IDS_STATUSBAR_LAYOUT_ROMANIA },
+ { "xkb:rs::srp", IDS_STATUSBAR_LAYOUT_SERBIA },
+ { "xkb:ru::rus", IDS_STATUSBAR_LAYOUT_RUSSIA },
+ { "xkb:ru:phonetic:rus", IDS_STATUSBAR_LAYOUT_RUSSIA_PHONETIC },
+ { "xkb:se::swe", IDS_STATUSBAR_LAYOUT_SWEDEN },
+ { "xkb:si::slv", IDS_STATUSBAR_LAYOUT_SLOVENIA },
+ { "xkb:sk::slo", IDS_STATUSBAR_LAYOUT_SLOVAKIA },
+ { "xkb:tr::tur", IDS_STATUSBAR_LAYOUT_TURKEY },
+ { "xkb:ua::ukr", IDS_STATUSBAR_LAYOUT_UKRAINE },
+ { "xkb:us::eng", IDS_STATUSBAR_LAYOUT_USA },
+ { "xkb:us::fil", IDS_STATUSBAR_LAYOUT_USA },
+ { "xkb:us::ind", IDS_STATUSBAR_LAYOUT_USA },
+ { "xkb:us::msa", IDS_STATUSBAR_LAYOUT_USA },
+ { "xkb:us:altgr-intl:eng", IDS_STATUSBAR_LAYOUT_USA_EXTENDED },
+ { "xkb:us:colemak:eng", IDS_STATUSBAR_LAYOUT_USA_COLEMAK },
+ { "xkb:us:dvorak:eng", IDS_STATUSBAR_LAYOUT_USA_DVORAK },
+ { "xkb:us:intl:eng", IDS_STATUSBAR_LAYOUT_USA_INTERNATIONAL },
+ { "xkb:us:intl:nld", IDS_STATUSBAR_LAYOUT_USA_INTERNATIONAL },
+ { "xkb:us:intl:por", IDS_STATUSBAR_LAYOUT_USA_INTERNATIONAL },
};
const size_t kEnglishToResourceIdArraySize =
arraysize(kEnglishToResourceIdArray);
} // namespace
-InputMethodUtil::InputMethodUtil(
- InputMethodDelegate* delegate,
- scoped_ptr<InputMethodDescriptors> supported_input_methods)
- : supported_input_methods_(supported_input_methods.Pass()),
- delegate_(delegate) {
- ReloadInternalMaps();
+namespace chromeos {
+
+namespace input_method {
+
+InputMethodUtil::InputMethodUtil(InputMethodDelegate* delegate)
+ : delegate_(delegate) {
+ InputMethodDescriptors default_input_methods;
+ default_input_methods.push_back(GetFallbackInputMethodDescriptor());
+ ResetInputMethods(default_input_methods);
// Initialize a map from English string to Chrome string resource ID as well.
for (size_t i = 0; i < kEnglishToResourceIdArraySize; ++i) {
DCHECK(result) << "Duplicated string is found: "
<< map_entry.english_string_from_ibus;
}
+
+ // Initialize the map from xkb layout to indicator text.
+ for (size_t i = 0; i < arraysize(kXkbIndicators); ++i) {
+ xkb_layout_to_indicator_[kXkbIndicators[i][0]] = kXkbIndicators[i][1];
+ }
}
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);
+ // |english_string| could be an input method id. So legacy xkb id is required
+ // to get the translated string.
+ std::string key_string = extension_ime_util::MaybeGetLegacyXkbId(
+ english_string);
+ HashType::const_iterator iter = english_to_resource_id_.find(key_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;
+ LOG(ERROR) << "Resource ID is not found for: " << english_string
+ << ", " << key_string;
return false;
}
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);
+ return base::UTF8ToUTF16(english_string);
}
bool InputMethodUtil::IsValidInputMethodId(
// We can't check the component extension is whilelisted or not here because
// it might not be initialized.
return GetInputMethodDescriptorFromId(input_method_id) != NULL ||
- ComponentExtensionIMEManager::IsComponentExtensionIMEId(input_method_id);
+ extension_ime_util::IsComponentExtensionIME(input_method_id);
}
// static
bool InputMethodUtil::IsKeyboardLayout(const std::string& input_method_id) {
- const bool kCaseInsensitive = false;
- return StartsWithASCII(input_method_id, "xkb:", kCaseInsensitive);
-}
-
-std::string InputMethodUtil::GetLanguageCodeFromInputMethodId(
- const std::string& input_method_id) const {
- // The code should be compatible with one of codes used for UI languages,
- // defined in app/l10_util.cc.
- const char kDefaultLanguageCode[] = "en-US";
- std::map<std::string, std::string>::const_iterator iter
- = id_to_language_code_.find(input_method_id);
- return (iter == id_to_language_code_.end()) ?
- // Returning |kDefaultLanguageCode| here is not for Chrome OS but for
- // Ubuntu where the ibus-xkb-layouts engine could be missing.
- kDefaultLanguageCode : iter->second;
+ return StartsWithASCII(input_method_id, "xkb:", false) ||
+ extension_ime_util::IsKeyboardLayoutExtension(input_method_id);
}
std::string InputMethodUtil::GetKeyboardLayoutName(
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 base::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;
+ // Use the indicator string if set.
+ if (!input_method.indicator().empty()) {
+ return base::UTF8ToUTF16(input_method.indicator());
+ }
+
+ 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);
+ if (extension_ime_util::GetInputMethodIDByEngineID(
+ kMappingFromIdToIndicatorText[i].engine_id) == input_method.id()) {
+ text = base::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 =
- UTF8ToUTF16(GetKeyboardLayoutName(input_method.id()));
- text = StringToUpperASCII(keyboard_layout).substr(
- 0, kMaxKeyboardLayoutNameLen);
+ if (text.empty() && IsKeyboardLayout(input_method.id())) {
+ std::map<std::string, std::string>::const_iterator it =
+ xkb_layout_to_indicator_.find(GetKeyboardLayoutName(input_method.id()));
+ if (it != xkb_layout_to_indicator_.end())
+ text = base::UTF8ToUTF16(it->second);
}
// TODO(yusukes): Some languages have two or more input methods. For example,
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(
+ text = StringToUpperASCII(base::UTF8ToUTF16(language_code)).substr(
0, kMaxLanguageNameLen);
}
- DCHECK(!text.empty());
+ DCHECK(!text.empty()) << input_method.id();
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 ==
+ if (extension_ime_util::GetInputMethodIDByEngineID(
+ kMappingImeIdToMediumLenNameResourceId[i].engine_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 (!input_method.name().empty() && !IsKeyboardLayout(input_method.id())) {
// If the descriptor has a name, use it.
- return UTF8ToUTF16(input_method.name());
+ return base::UTF8ToUTF16(input_method.name());
}
// We don't show language here. Name of keyboard layout or input method
// 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;
+ text = language_name + base::UTF8ToUTF16(" - ") + text;
}
DCHECK(!text.empty());
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);
+ InputMethodIdToDescriptorMap::const_iterator iter =
+ id_to_descriptor_.find(input_method_id);
+ if (iter == id_to_descriptor_.end())
+ return NULL;
+ return &(iter->second);
}
bool InputMethodUtil::GetInputMethodIdsFromLanguageCode(
if (kDefaultInputMethodRecommendation[i].locale == language_code &&
kDefaultInputMethodRecommendation[i].layout == current_layout) {
out_input_method_ids->push_back(
- kDefaultInputMethodRecommendation[i].input_method_id);
+ extension_ime_util::GetInputMethodIDByEngineID(
+ kDefaultInputMethodRecommendation[i].engine_id));
return;
}
}
}
// Add the most popular input method ID, if it's different from the
// current input method.
- if (most_popular_id != current_input_method.id() &&
- // TODO(yusukes): Remove this hack when we remove the "english-m" IME.
- most_popular_id != "english-m") {
+ if (most_popular_id != current_input_method.id()) {
out_input_method_ids->push_back(most_popular_id);
}
}
}
}
-std::string InputMethodUtil::GetHardwareInputMethodId() const {
- const std::string input_method_id = delegate_->GetHardwareKeyboardLayout();
+std::string InputMethodUtil::GetLanguageDefaultInputMethodId(
+ const std::string& language_code) {
+ std::vector<std::string> candidates;
+ GetInputMethodIdsFromLanguageCode(
+ language_code, input_method::kKeyboardLayoutsOnly, &candidates);
+ if (candidates.size())
+ return candidates.front();
+
+ return std::string();
+}
- if (input_method_id.empty()) {
+bool InputMethodUtil::MigrateInputMethods(
+ std::vector<std::string>* input_method_ids) {
+ bool rewritten = false;
+ std::vector<std::string>& ids = *input_method_ids;
+ for (size_t i = 0; i < ids.size(); ++i) {
+ std::string engine_id = ids[i];
+ // Migrates some Engine IDs from VPD.
+ for (size_t j = 0; j < arraysize(kEngineIdMigrationMap); ++j) {
+ size_t pos = engine_id.find(kEngineIdMigrationMap[j][0]);
+ if (pos == 0)
+ engine_id.replace(pos, strlen(kEngineIdMigrationMap[j][0]),
+ kExtensionIdMigrationMap[j][1]);
+ }
+ std::string id =
+ extension_ime_util::GetInputMethodIDByEngineID(engine_id);
+ // Migrates old ime id's to new ones.
+ for (size_t j = 0; j < arraysize(kExtensionIdMigrationMap); ++j) {
+ size_t pos = id.find(kExtensionIdMigrationMap[j][0]);
+ if (pos != std::string::npos)
+ id.replace(pos, kExtensionIdLen, kExtensionIdMigrationMap[j][1]);
+ if (id != ids[i]) {
+ ids[i] = id;
+ rewritten = true;
+ }
+ }
+ }
+ if (rewritten) {
+ // Removes the duplicates.
+ std::vector<std::string> new_ids;
+ for (size_t i = 0; i < ids.size(); ++i) {
+ if (std::find(new_ids.begin(), new_ids.end(), ids[i]) == new_ids.end())
+ new_ids.push_back(ids[i]);
+ }
+ ids.swap(new_ids);
+ }
+ return rewritten;
+}
+
+void InputMethodUtil::UpdateHardwareLayoutCache() {
+ DCHECK(thread_checker_.CalledOnValidThread());
+ hardware_layouts_.clear();
+ hardware_login_layouts_.clear();
+ if (cached_hardware_layouts_.empty())
+ Tokenize(delegate_->GetHardwareKeyboardLayouts(), ",",
+ &cached_hardware_layouts_);
+ hardware_layouts_ = cached_hardware_layouts_;
+ MigrateInputMethods(&hardware_layouts_);
+
+ for (size_t i = 0; i < hardware_layouts_.size(); ++i) {
+ if (IsLoginKeyboard(hardware_layouts_[i]))
+ hardware_login_layouts_.push_back(hardware_layouts_[i]);
+ }
+ if (hardware_layouts_.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 GetFallbackInputMethodDescriptor().id();
+ hardware_layouts_.push_back(GetFallbackInputMethodDescriptor().id());
}
- return input_method_id;
+
+ if (hardware_login_layouts_.empty())
+ hardware_login_layouts_.push_back(GetFallbackInputMethodDescriptor().id());
}
-void InputMethodUtil::SetComponentExtensions(
- const InputMethodDescriptors& imes) {
- component_extension_ime_id_to_descriptor_.clear();
- for (size_t i = 0; i < imes.size(); ++i) {
- const InputMethodDescriptor& input_method = imes.at(i);
- DCHECK(!input_method.language_codes().empty());
- const std::string language_code = input_method.language_codes().at(0);
- id_to_language_code_.insert(
- std::make_pair(input_method.id(), language_code));
- id_to_descriptor_.insert(
- std::make_pair(input_method.id(), input_method));
- }
+void InputMethodUtil::SetHardwareKeyboardLayoutForTesting(
+ const std::string& layout) {
+ delegate_->SetHardwareKeyboardLayoutForTesting(layout);
+ cached_hardware_layouts_.clear();
+ UpdateHardwareLayoutCache();
}
-InputMethodDescriptor InputMethodUtil::GetFallbackInputMethodDescriptor() {
- std::vector<std::string> layouts;
- layouts.push_back("us");
- std::vector<std::string> languages;
- languages.push_back("en-US");
- return InputMethodDescriptor("xkb:us::eng",
- "",
- layouts,
- languages,
- true, // login keyboard.
- GURL()); // options page, not available.
+const std::vector<std::string>&
+ InputMethodUtil::GetHardwareInputMethodIds() {
+ DCHECK(thread_checker_.CalledOnValidThread());
+ UpdateHardwareLayoutCache();
+ return hardware_layouts_;
}
-void InputMethodUtil::ReloadInternalMaps() {
- if (supported_input_methods_->size() <= 1) {
- DVLOG(1) << "GetSupportedInputMethods returned a fallback ID";
- // TODO(yusukes): Handle this error in nicer way.
- }
+const std::vector<std::string>&
+ InputMethodUtil::GetHardwareLoginInputMethodIds() {
+ DCHECK(thread_checker_.CalledOnValidThread());
+ UpdateHardwareLayoutCache();
+ return hardware_login_layouts_;
+}
- // Clear the existing maps.
- language_code_to_ids_.clear();
- id_to_language_code_.clear();
- id_to_descriptor_.clear();
- xkb_id_to_descriptor_.clear();
+bool InputMethodUtil::IsLoginKeyboard(const std::string& input_method_id)
+ const {
+ const InputMethodDescriptor* ime =
+ GetInputMethodDescriptorFromId(input_method_id);
+ return ime ? ime->is_login_keyboard() : false;
+}
- for (size_t i = 0; i < supported_input_methods_->size(); ++i) {
- const InputMethodDescriptor& input_method =
- supported_input_methods_->at(i);
+void InputMethodUtil::AppendInputMethods(const InputMethodDescriptors& imes) {
+ for (size_t i = 0; i < imes.size(); ++i) {
+ const InputMethodDescriptor& input_method = imes[i];
+ DCHECK(!input_method.language_codes().empty());
const std::vector<std::string>& language_codes =
input_method.language_codes();
- for (size_t i = 0; i < language_codes.size(); ++i) {
- language_code_to_ids_.insert(
- std::make_pair(language_codes[i], input_method.id()));
- // Remember the pairs.
- id_to_language_code_.insert(
- std::make_pair(input_method.id(), language_codes[i]));
- }
- id_to_descriptor_.insert(
- std::make_pair(input_method.id(), input_method));
- if (IsKeyboardLayout(input_method.id())) {
- xkb_id_to_descriptor_.insert(
- std::make_pair(input_method.GetPreferredKeyboardLayout(),
- input_method));
+ id_to_descriptor_[input_method.id()] = input_method;
+
+ typedef LanguageCodeToIdsMap::const_iterator It;
+ for (size_t j = 0; j < language_codes.size(); ++j) {
+ std::pair<It, It> range =
+ language_code_to_ids_.equal_range(language_codes[j]);
+ It it = range.first;
+ for (; it != range.second; ++it) {
+ if (it->second == input_method.id())
+ break;
+ }
+ if (it == range.second)
+ language_code_to_ids_.insert(
+ std::make_pair(language_codes[j], input_method.id()));
}
}
}
+void InputMethodUtil::ResetInputMethods(const InputMethodDescriptors& imes) {
+ // Clear the existing maps.
+ language_code_to_ids_.clear();
+ id_to_descriptor_.clear();
+
+ AppendInputMethods(imes);
+}
+
+void InputMethodUtil::InitXkbInputMethodsForTesting() {
+ cached_hardware_layouts_.clear();
+ ResetInputMethods(*(InputMethodWhitelist().GetSupportedInputMethods()));
+}
+
+const InputMethodUtil::InputMethodIdToDescriptorMap&
+InputMethodUtil::GetIdToDesciptorMapForTesting() {
+ return id_to_descriptor_;
+}
+
+InputMethodDescriptor InputMethodUtil::GetFallbackInputMethodDescriptor() {
+ std::vector<std::string> layouts;
+ layouts.push_back("us");
+ std::vector<std::string> languages;
+ languages.push_back("en-US");
+ return InputMethodDescriptor(
+ extension_ime_util::GetInputMethodIDByEngineID("xkb:us::eng"),
+ "",
+ "US",
+ layouts,
+ languages,
+ true, // login keyboard.
+ GURL(), // options page, not available.
+ GURL()); // input view page, not available.
+}
+
} // namespace input_method
} // namespace chromeos
projects / platform / framework / web / crosswalk.git / blobdiff