Home | History | Annotate | Download | only in chromeos 
      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/ui/webui/options/chromeos/cros_language_options_handler.h"
      6 
      7 #include <algorithm>
      8 #include <iterator>
      9 #include <map>
     10 #include <set>
     11 #include <vector>
     12 
     13 #include "base/bind.h"
     14 #include "base/bind_helpers.h"
     15 #include "base/i18n/rtl.h"
     16 #include "base/strings/stringprintf.h"
     17 #include "base/strings/utf_string_conversions.h"
     18 #include "base/values.h"
     19 #include "chrome/app/chrome_command_ids.h"
     20 #include "chrome/browser/browser_process.h"
     21 #include "chrome/browser/chromeos/customization_document.h"
     22 #include "chrome/browser/chromeos/input_method/input_method_util.h"
     23 #include "chrome/browser/chromeos/login/users/user_manager.h"
     24 #include "chrome/browser/extensions/extension_service.h"
     25 #include "chrome/browser/extensions/extension_tab_util.h"
     26 #include "chrome/browser/lifetime/application_lifetime.h"
     27 #include "chrome/browser/profiles/profile.h"
     28 #include "chrome/browser/ui/browser.h"
     29 #include "chrome/browser/ui/browser_finder.h"
     30 #include "chrome/browser/ui/browser_window.h"
     31 #include "chrome/browser/ui/tabs/tab_strip_model.h"
     32 #include "chrome/common/extensions/manifest_url_handler.h"
     33 #include "chromeos/ime/component_extension_ime_manager.h"
     34 #include "chromeos/ime/extension_ime_util.h"
     35 #include "chromeos/ime/input_method_manager.h"
     36 #include "content/public/browser/navigation_controller.h"
     37 #include "content/public/browser/user_metrics.h"
     38 #include "content/public/browser/web_contents.h"
     39 #include "extensions/browser/extension_system.h"
     40 #include "extensions/common/extension.h"
     41 #include "grit/chromium_strings.h"
     42 #include "grit/generated_resources.h"
     43 #include "ui/base/l10n/l10n_util.h"
     44 
     45 using base::UserMetricsAction;
     46 
     47 namespace {
     48 // TODO(zork): Remove this blacklist when fonts are added to Chrome OS.
     49 // see: crbug.com/240586
     50 
     51 bool IsBlacklisted(const std::string& language_code) {
     52   return language_code == "si"; // Sinhala
     53 }
     54 
     55 } // namespace
     56 
     57 namespace chromeos {
     58 namespace options {
     59 
     60 const char kVendorOtherLanguagesListDivider[] =
     61     "VENDOR_OTHER_LANGUAGES_LIST_DIVIDER";
     62 
     63 CrosLanguageOptionsHandler::CrosLanguageOptionsHandler()
     64     : composition_extension_appended_(false),
     65       is_page_initialized_(false) {
     66   input_method::InputMethodManager::Get()->GetComponentExtensionIMEManager()->
     67       AddObserver(this);
     68 }
     69 
     70 CrosLanguageOptionsHandler::~CrosLanguageOptionsHandler() {
     71   input_method::InputMethodManager::Get()->GetComponentExtensionIMEManager()->
     72       RemoveObserver(this);
     73 }
     74 
     75 void CrosLanguageOptionsHandler::GetLocalizedValues(
     76     base::DictionaryValue* localized_strings) {
     77   ::options::LanguageOptionsHandlerCommon::GetLocalizedValues(
     78       localized_strings);
     79 
     80   RegisterTitle(localized_strings, "languagePage",
     81                 IDS_OPTIONS_SETTINGS_LANGUAGES_AND_INPUT_DIALOG_TITLE);
     82   localized_strings->SetString("okButton", l10n_util::GetStringUTF16(IDS_OK));
     83   localized_strings->SetString("configure",
     84       l10n_util::GetStringUTF16(IDS_OPTIONS_SETTINGS_LANGUAGES_CONFIGURE));
     85   localized_strings->SetString("inputMethod",
     86       l10n_util::GetStringUTF16(IDS_OPTIONS_SETTINGS_LANGUAGES_INPUT_METHOD));
     87   localized_strings->SetString("pleaseAddAnotherInputMethod",
     88       l10n_util::GetStringUTF16(
     89           IDS_OPTIONS_SETTINGS_LANGUAGES_PLEASE_ADD_ANOTHER_INPUT_METHOD));
     90   localized_strings->SetString("inputMethodInstructions",
     91       l10n_util::GetStringUTF16(
     92           IDS_OPTIONS_SETTINGS_LANGUAGES_INPUT_METHOD_INSTRUCTIONS));
     93   localized_strings->SetString("switchInputMethodsHint",
     94       l10n_util::GetStringUTF16(
     95           IDS_OPTIONS_SETTINGS_LANGUAGES_SWITCH_INPUT_METHODS_HINT));
     96   localized_strings->SetString("selectPreviousInputMethodHint",
     97       l10n_util::GetStringUTF16(
     98           IDS_OPTIONS_SETTINGS_LANGUAGES_SELECT_PREVIOUS_INPUT_METHOD_HINT));
     99   localized_strings->SetString("restartButton",
    100       l10n_util::GetStringUTF16(
    101           IDS_OPTIONS_SETTINGS_LANGUAGES_SIGN_OUT_BUTTON));
    102   localized_strings->SetString("extensionImeLable",
    103       l10n_util::GetStringUTF16(
    104           IDS_OPTIONS_SETTINGS_LANGUAGES_INPUT_METHOD_EXTENSION_IME));
    105   localized_strings->SetString("extensionImeDescription",
    106       l10n_util::GetStringUTF16(
    107           IDS_OPTIONS_SETTINGS_LANGUAGES_INPUT_METHOD_EXTENSION_DESCRIPTION));
    108   localized_strings->SetString("noInputMethods",
    109       l10n_util::GetStringUTF16(
    110           IDS_OPTIONS_SETTINGS_LANGUAGES_NO_INPUT_METHODS));
    111 
    112   input_method::InputMethodManager* manager =
    113       input_method::InputMethodManager::Get();
    114   // GetSupportedInputMethods() never return NULL.
    115   scoped_ptr<input_method::InputMethodDescriptors> descriptors(
    116       manager->GetSupportedInputMethods());
    117   localized_strings->Set("languageList", GetAcceptLanguageList(*descriptors));
    118   localized_strings->Set("inputMethodList", GetInputMethodList(*descriptors));
    119 
    120   input_method::InputMethodDescriptors ext_ime_descriptors;
    121   manager->GetInputMethodExtensions(&ext_ime_descriptors);
    122 
    123   base::ListValue* ext_ime_list = ConvertInputMethodDescriptorsToIMEList(
    124       ext_ime_descriptors);
    125   AddImeProvider(ext_ime_list);
    126   localized_strings->Set("extensionImeList", ext_ime_list);
    127 
    128   ComponentExtensionIMEManager* component_extension_manager =
    129       input_method::InputMethodManager::Get()
    130           ->GetComponentExtensionIMEManager();
    131   if (component_extension_manager->IsInitialized()) {
    132     localized_strings->Set(
    133         "componentExtensionImeList",
    134         ConvertInputMethodDescriptorsToIMEList(
    135             component_extension_manager->GetAllIMEAsInputMethodDescriptor()));
    136     composition_extension_appended_ = true;
    137   } else {
    138     // If component extension IME manager is not ready for use, it will be
    139     // added in |InitializePage()|.
    140     localized_strings->Set("componentExtensionImeList",
    141                            new base::ListValue());
    142   }
    143 }
    144 
    145 void CrosLanguageOptionsHandler::RegisterMessages() {
    146   ::options::LanguageOptionsHandlerCommon::RegisterMessages();
    147 
    148   web_ui()->RegisterMessageCallback("inputMethodDisable",
    149       base::Bind(&CrosLanguageOptionsHandler::InputMethodDisableCallback,
    150                  base::Unretained(this)));
    151   web_ui()->RegisterMessageCallback("inputMethodEnable",
    152       base::Bind(&CrosLanguageOptionsHandler::InputMethodEnableCallback,
    153                  base::Unretained(this)));
    154   web_ui()->RegisterMessageCallback("inputMethodOptionsOpen",
    155       base::Bind(&CrosLanguageOptionsHandler::InputMethodOptionsOpenCallback,
    156                  base::Unretained(this)));
    157   web_ui()->RegisterMessageCallback("uiLanguageRestart",
    158       base::Bind(&CrosLanguageOptionsHandler::RestartCallback,
    159                  base::Unretained(this)));
    160 }
    161 
    162 // static
    163 base::ListValue* CrosLanguageOptionsHandler::GetInputMethodList(
    164     const input_method::InputMethodDescriptors& descriptors) {
    165   input_method::InputMethodManager* manager =
    166       input_method::InputMethodManager::Get();
    167 
    168   base::ListValue* input_method_list = new base::ListValue();
    169 
    170   for (size_t i = 0; i < descriptors.size(); ++i) {
    171     const input_method::InputMethodDescriptor& descriptor =
    172         descriptors[i];
    173     const std::string display_name =
    174         manager->GetInputMethodUtil()->GetInputMethodDisplayNameFromId(
    175             descriptor.id());
    176     base::DictionaryValue* dictionary = new base::DictionaryValue();
    177     dictionary->SetString("id", descriptor.id());
    178     dictionary->SetString("displayName", display_name);
    179 
    180     // One input method can be associated with multiple languages, hence
    181     // we use a dictionary here.
    182     base::DictionaryValue* languages = new base::DictionaryValue();
    183     for (size_t i = 0; i < descriptor.language_codes().size(); ++i) {
    184       languages->SetBoolean(descriptor.language_codes().at(i), true);
    185     }
    186     dictionary->Set("languageCodeSet", languages);
    187 
    188     input_method_list->Append(dictionary);
    189   }
    190 
    191   return input_method_list;
    192 }
    193 
    194 // static
    195 base::ListValue* CrosLanguageOptionsHandler::GetLanguageListInternal(
    196     const input_method::InputMethodDescriptors& descriptors,
    197     const std::vector<std::string>& base_language_codes,
    198     const bool insert_divider) {
    199   const std::string app_locale = g_browser_process->GetApplicationLocale();
    200 
    201   std::set<std::string> language_codes;
    202   // Collect the language codes from the supported input methods.
    203   for (size_t i = 0; i < descriptors.size(); ++i) {
    204     const input_method::InputMethodDescriptor& descriptor = descriptors[i];
    205     const std::vector<std::string>& languages =
    206         descriptor.language_codes();
    207     for (size_t i = 0; i < languages.size(); ++i)
    208       language_codes.insert(languages[i]);
    209   }
    210 
    211   const StartupCustomizationDocument* startup_manifest =
    212       StartupCustomizationDocument::GetInstance();
    213 
    214   const std::vector<std::string>& configured_locales =
    215       startup_manifest->configured_locales();
    216 
    217   // Languages sort order.
    218   std::map<std::string, int /* index */> language_index;
    219   for (size_t i = 0; i < configured_locales.size(); ++i) {
    220     language_index[configured_locales[i]] = i;
    221   }
    222 
    223   // Map of display name -> {language code, native_display_name}.
    224   // In theory, we should be able to create a map that is sorted by
    225   // display names using ICU comparator, but doing it is hard, thus we'll
    226   // use an auxiliary vector to achieve the same result.
    227   typedef std::pair<std::string, base::string16> LanguagePair;
    228   typedef std::map<base::string16, LanguagePair> LanguageMap;
    229   LanguageMap language_map;
    230 
    231   // The auxiliary vector mentioned above. (except vendor locales)
    232   std::vector<base::string16> display_names;
    233 
    234   // Separate vector of vendor locales.
    235   std::vector<base::string16> configured_locales_display_names(
    236       configured_locales.size());
    237 
    238   size_t configured_locales_count = 0;
    239 
    240   // Build the list of display names, and build the language map.
    241 
    242   // The list of configured locales might have entries not in
    243   // base_language_codes. If there are unsupported language variants,
    244   // but they resolve to backup locale within base_language_codes, also
    245   // add them to the list.
    246   for (std::map<std::string, int>::const_iterator iter = language_index.begin();
    247        iter != language_index.end();
    248        ++iter) {
    249     const std::string& language_id = iter->first;
    250     const int language_idx = iter->second;
    251 
    252     const size_t dash_pos = language_id.find_first_of('-');
    253 
    254     // Ignore non-specific codes.
    255     if (dash_pos == std::string::npos || dash_pos == 0)
    256       continue;
    257 
    258     if (std::find(base_language_codes.begin(),
    259                   base_language_codes.end(),
    260                   language_id) != base_language_codes.end()) {
    261       // Language is supported. No need to replace
    262       continue;
    263     }
    264     std::string resolved_locale;
    265     if (!l10n_util::CheckAndResolveLocale(language_id, &resolved_locale))
    266       continue;
    267 
    268     if (std::find(base_language_codes.begin(),
    269                   base_language_codes.end(),
    270                   resolved_locale) == base_language_codes.end()) {
    271       // Resolved locale is not supported.
    272       continue;
    273     }
    274 
    275     const base::string16 display_name =
    276         l10n_util::GetDisplayNameForLocale(language_id, app_locale, true);
    277     const base::string16 native_display_name =
    278         l10n_util::GetDisplayNameForLocale(
    279             language_id, language_id, true);
    280 
    281     language_map[display_name] =
    282         std::make_pair(language_id, native_display_name);
    283 
    284     configured_locales_display_names[language_idx] = display_name;
    285     ++configured_locales_count;
    286   }
    287 
    288   // Translate language codes, generated from input methods.
    289   for (std::set<std::string>::const_iterator iter = language_codes.begin();
    290        iter != language_codes.end(); ++iter) {
    291      // Exclude the language which is not in |base_langauge_codes| even it has
    292      // input methods.
    293     if (std::find(base_language_codes.begin(),
    294                   base_language_codes.end(),
    295                   *iter) == base_language_codes.end()) {
    296       continue;
    297     }
    298 
    299     const base::string16 display_name =
    300         l10n_util::GetDisplayNameForLocale(*iter, app_locale, true);
    301     const base::string16 native_display_name =
    302         l10n_util::GetDisplayNameForLocale(*iter, *iter, true);
    303 
    304     language_map[display_name] =
    305         std::make_pair(*iter, native_display_name);
    306 
    307     const std::map<std::string, int>::const_iterator index_pos =
    308         language_index.find(*iter);
    309     if (index_pos != language_index.end()) {
    310       base::string16& stored_display_name =
    311           configured_locales_display_names[index_pos->second];
    312       if (stored_display_name.empty()) {
    313         stored_display_name = display_name;
    314         ++configured_locales_count;
    315       }
    316     } else {
    317       display_names.push_back(display_name);
    318     }
    319   }
    320   DCHECK_EQ(display_names.size() + configured_locales_count,
    321             language_map.size());
    322 
    323   // Build the list of display names, and build the language map.
    324   for (size_t i = 0; i < base_language_codes.size(); ++i) {
    325     // Skip this language if it was already added.
    326     if (language_codes.find(base_language_codes[i]) != language_codes.end())
    327       continue;
    328 
    329     // TODO(zork): Remove this blacklist when fonts are added to Chrome OS.
    330     // see: crbug.com/240586
    331     if (IsBlacklisted(base_language_codes[i]))
    332       continue;
    333 
    334     base::string16 display_name =
    335         l10n_util::GetDisplayNameForLocale(
    336             base_language_codes[i], app_locale, false);
    337     base::string16 native_display_name =
    338         l10n_util::GetDisplayNameForLocale(
    339             base_language_codes[i], base_language_codes[i], false);
    340     language_map[display_name] =
    341         std::make_pair(base_language_codes[i], native_display_name);
    342 
    343     const std::map<std::string, int>::const_iterator index_pos =
    344         language_index.find(base_language_codes[i]);
    345     if (index_pos != language_index.end()) {
    346       configured_locales_display_names[index_pos->second] = display_name;
    347       ++configured_locales_count;
    348     } else {
    349       display_names.push_back(display_name);
    350     }
    351   }
    352 
    353   // Sort display names using locale specific sorter.
    354   l10n_util::SortStrings16(app_locale, &display_names);
    355   // Concatenate configured_locales_display_names and display_names.
    356   // Insert special divider in between.
    357   std::vector<base::string16> out_display_names;
    358   for (size_t i = 0; i < configured_locales_display_names.size(); ++i) {
    359     if (configured_locales_display_names[i].size() == 0)
    360       continue;
    361     out_display_names.push_back(configured_locales_display_names[i]);
    362   }
    363 
    364   base::string16 divider16;
    365   if (insert_divider) {
    366     divider16 = base::ASCIIToUTF16(
    367         insert_divider ? "" : kVendorOtherLanguagesListDivider);
    368     out_display_names.push_back(divider16);
    369   }
    370 
    371   std::copy(display_names.begin(),
    372             display_names.end(),
    373             std::back_inserter(out_display_names));
    374 
    375   // Build the language list from the language map.
    376   base::ListValue* language_list = new base::ListValue();
    377   for (size_t i = 0; i < out_display_names.size(); ++i) {
    378     // Sets the directionality of the display language name.
    379     base::string16 display_name(out_display_names[i]);
    380     if (insert_divider && display_name == divider16) {
    381       // Insert divider.
    382       base::DictionaryValue* dictionary = new base::DictionaryValue();
    383       dictionary->SetString("code", kVendorOtherLanguagesListDivider);
    384       language_list->Append(dictionary);
    385       continue;
    386     }
    387     bool markup_removal =
    388         base::i18n::UnadjustStringForLocaleDirection(&display_name);
    389     DCHECK(markup_removal);
    390     bool has_rtl_chars = base::i18n::StringContainsStrongRTLChars(display_name);
    391     std::string directionality = has_rtl_chars ? "rtl" : "ltr";
    392 
    393     const LanguagePair& pair = language_map[out_display_names[i]];
    394     base::DictionaryValue* dictionary = new base::DictionaryValue();
    395     dictionary->SetString("code", pair.first);
    396     dictionary->SetString("displayName", out_display_names[i]);
    397     dictionary->SetString("textDirection", directionality);
    398     dictionary->SetString("nativeDisplayName", pair.second);
    399     language_list->Append(dictionary);
    400   }
    401 
    402   return language_list;
    403 }
    404 
    405 // static
    406 base::ListValue* CrosLanguageOptionsHandler::GetAcceptLanguageList(
    407     const input_method::InputMethodDescriptors& descriptors) {
    408   // Collect the language codes from the supported accept-languages.
    409   const std::string app_locale = g_browser_process->GetApplicationLocale();
    410   std::vector<std::string> accept_language_codes;
    411   l10n_util::GetAcceptLanguagesForLocale(app_locale, &accept_language_codes);
    412   return GetLanguageListInternal(descriptors, accept_language_codes, false);
    413 }
    414 
    415 // static
    416 base::ListValue* CrosLanguageOptionsHandler::GetUILanguageList(
    417     const input_method::InputMethodDescriptors& descriptors) {
    418   // Collect the language codes from the available locales.
    419   return GetLanguageListInternal(
    420       descriptors, l10n_util::GetAvailableLocales(), true);
    421 }
    422 
    423 base::ListValue*
    424     CrosLanguageOptionsHandler::ConvertInputMethodDescriptorsToIMEList(
    425         const input_method::InputMethodDescriptors& descriptors) {
    426   scoped_ptr<base::ListValue> ime_ids_list(new base::ListValue());
    427   for (size_t i = 0; i < descriptors.size(); ++i) {
    428     const input_method::InputMethodDescriptor& descriptor = descriptors[i];
    429     scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue());
    430     dictionary->SetString("id", descriptor.id());
    431     dictionary->SetString("displayName", descriptor.name());
    432     dictionary->SetString("optionsPage", descriptor.options_page_url().spec());
    433     scoped_ptr<base::DictionaryValue> language_codes(
    434         new base::DictionaryValue());
    435     for (size_t i = 0; i < descriptor.language_codes().size(); ++i)
    436       language_codes->SetBoolean(descriptor.language_codes().at(i), true);
    437     dictionary->Set("languageCodeSet", language_codes.release());
    438     ime_ids_list->Append(dictionary.release());
    439   }
    440   return ime_ids_list.release();
    441 }
    442 
    443 base::string16 CrosLanguageOptionsHandler::GetProductName() {
    444   return l10n_util::GetStringUTF16(IDS_SHORT_PRODUCT_OS_NAME);
    445 }
    446 
    447 void CrosLanguageOptionsHandler::SetApplicationLocale(
    448     const std::string& language_code) {
    449   Profile* profile = Profile::FromWebUI(web_ui());
    450   UserManager* user_manager = UserManager::Get();
    451 
    452   // Only the primary user can change the locale.
    453   User* user = user_manager->GetUserByProfile(profile);
    454   if (user && user->email() == user_manager->GetPrimaryUser()->email()) {
    455     profile->ChangeAppLocale(language_code,
    456                              Profile::APP_LOCALE_CHANGED_VIA_SETTINGS);
    457   }
    458 }
    459 
    460 void CrosLanguageOptionsHandler::RestartCallback(const base::ListValue* args) {
    461   content::RecordAction(UserMetricsAction("LanguageOptions_SignOut"));
    462   chrome::AttemptUserExit();
    463 }
    464 
    465 void CrosLanguageOptionsHandler::InputMethodDisableCallback(
    466     const base::ListValue* args) {
    467   const std::string input_method_id =
    468       base::UTF16ToASCII(ExtractStringValue(args));
    469   const std::string action = base::StringPrintf(
    470       "LanguageOptions_DisableInputMethod_%s", input_method_id.c_str());
    471   content::RecordComputedAction(action);
    472 }
    473 
    474 void CrosLanguageOptionsHandler::InputMethodEnableCallback(
    475     const base::ListValue* args) {
    476   const std::string input_method_id =
    477       base::UTF16ToASCII(ExtractStringValue(args));
    478   const std::string action = base::StringPrintf(
    479       "LanguageOptions_EnableInputMethod_%s", input_method_id.c_str());
    480   content::RecordComputedAction(action);
    481 }
    482 
    483 void CrosLanguageOptionsHandler::InputMethodOptionsOpenCallback(
    484     const base::ListValue* args) {
    485   const std::string input_method_id =
    486       base::UTF16ToASCII(ExtractStringValue(args));
    487   const std::string extension_id =
    488       extension_ime_util::GetExtensionIDFromInputMethodID(input_method_id);
    489   if (extension_id.empty())
    490     return;
    491 
    492   const input_method::InputMethodDescriptor* ime =
    493       input_method::InputMethodManager::Get()->GetInputMethodFromId(
    494           input_method_id);
    495   if (!ime)
    496     return;
    497 
    498   Browser* browser = chrome::FindBrowserWithWebContents(
    499       web_ui()->GetWebContents());
    500   content::OpenURLParams params(ime->options_page_url(),
    501       content::Referrer(),
    502       SINGLETON_TAB,
    503       content::PAGE_TRANSITION_LINK,
    504       false);
    505   browser->OpenURL(params);
    506   browser->window()->Show();
    507   content::WebContents* web_contents =
    508       browser->tab_strip_model()->GetActiveWebContents();
    509   web_contents->GetDelegate()->ActivateContents(web_contents);
    510 }
    511 
    512 void CrosLanguageOptionsHandler::OnImeComponentExtensionInitialized() {
    513   if (composition_extension_appended_ || !is_page_initialized_) {
    514     // If an option page is not ready to call JavaScript, appending component
    515     // extension IMEs will be done in InitializePage function later.
    516     return;
    517   }
    518 
    519   ComponentExtensionIMEManager* manager =
    520       input_method::InputMethodManager::Get()
    521           ->GetComponentExtensionIMEManager();
    522 
    523   DCHECK(manager->IsInitialized());
    524   scoped_ptr<base::ListValue> ime_list(
    525       ConvertInputMethodDescriptorsToIMEList(
    526           manager->GetAllIMEAsInputMethodDescriptor()));
    527   web_ui()->CallJavascriptFunction(
    528       "options.LanguageOptions.onComponentManagerInitialized",
    529       *ime_list);
    530   composition_extension_appended_ = true;
    531 }
    532 
    533 void CrosLanguageOptionsHandler::InitializePage() {
    534   is_page_initialized_ = true;
    535   if (composition_extension_appended_)
    536     return;
    537 
    538   ComponentExtensionIMEManager* component_extension_manager =
    539       input_method::InputMethodManager::Get()
    540           ->GetComponentExtensionIMEManager();
    541   if (!component_extension_manager->IsInitialized()) {
    542     // If the component extension IME manager is not available yet, append the
    543     // component extension list in |OnInitialized()|.
    544     return;
    545   }
    546 
    547   scoped_ptr<base::ListValue> ime_list(
    548       ConvertInputMethodDescriptorsToIMEList(
    549           component_extension_manager->GetAllIMEAsInputMethodDescriptor()));
    550   web_ui()->CallJavascriptFunction(
    551       "options.LanguageOptions.onComponentManagerInitialized",
    552       *ime_list);
    553   composition_extension_appended_ = true;
    554 }
    555 
    556 void CrosLanguageOptionsHandler::AddImeProvider(base::ListValue* list) {
    557   Profile* profile = Profile::FromWebUI(web_ui());
    558   ExtensionService* extension_service = profile->GetExtensionService();
    559   for (size_t i = 0; i < list->GetSize(); i++) {
    560     base::DictionaryValue* entry;
    561     list->GetDictionary(i, &entry);
    562 
    563     std::string input_method_id;
    564     entry->GetString("id", &input_method_id);
    565 
    566     std::string extension_id =
    567         extension_ime_util::GetExtensionIDFromInputMethodID(input_method_id);
    568     const extensions::Extension* extension =
    569         extension_service->GetExtensionById(extension_id, false);
    570     if (extension)
    571       entry->SetString("extensionName", extension->name());
    572   }
    573 }
    574 
    575 }  // namespace options
    576 }  // namespace chromeos
    577