chrome/browser/ui/webui/options/language_options_handler_common.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/ui/webui/options/language_options_handler_common.h"
   6
   7 #include <map>
   8 #include <string>
   9 #include <utility>
  10 #include <vector>
  11
  12 #include "base/basictypes.h"
  13 #include "base/bind.h"
  14 #include "base/command_line.h"
  15 #include "base/prefs/pref_service.h"
  16 #include "base/strings/string_util.h"
  17 #include "base/strings/stringprintf.h"
  18 #include "base/strings/utf_string_conversions.h"
  19 #include "base/values.h"
  20 #include "chrome/browser/browser_process.h"
  21 #include "chrome/browser/profiles/profile.h"
  22 #include "chrome/browser/spellchecker/spellcheck_factory.h"
  23 #include "chrome/browser/spellchecker/spellcheck_service.h"
  24 #include "chrome/browser/translate/chrome_translate_client.h"
  25 #include "chrome/browser/translate/translate_service.h"
  26 #include "chrome/browser/ui/browser_list.h"
  27 #include "chrome/common/chrome_switches.h"
  28 #include "chrome/common/pref_names.h"
  29 #include "chrome/common/spellcheck_common.h"
  30 #include "chrome/grit/chromium_strings.h"
  31 #include "chrome/grit/generated_resources.h"
  32 #include "components/translate/core/browser/translate_download_manager.h"
  33 #include "components/translate/core/browser/translate_prefs.h"
  34 #include "content/public/browser/user_metrics.h"
  35 #include "content/public/browser/web_ui.h"
  36 #include "ui/base/l10n/l10n_util.h"
  37
  38 using base::UserMetricsAction;
  39
  40 namespace options {
  41
  42 LanguageOptionsHandlerCommon::LanguageOptionsHandlerCommon() {
  43 }
  44
  45 LanguageOptionsHandlerCommon::~LanguageOptionsHandlerCommon() {
  46 }
  47
  48 void LanguageOptionsHandlerCommon::GetLocalizedValues(
  49     base::DictionaryValue* localized_strings) {
  50   DCHECK(localized_strings);
  51   static OptionsStringResource resources[] = {
  52     { "addButton", IDS_OPTIONS_SETTINGS_LANGUAGES_ADD_BUTTON },
  53     { "languages", IDS_OPTIONS_SETTINGS_LANGUAGES_LANGUAGES },
  54     { "addLanguageInstructions",
  55       IDS_OPTIONS_SETTINGS_LANGUAGES_ADD_LANGUAGE_INSTRUCTIONS },
  56     { "cannotBeDisplayedInThisLanguage",
  57       IDS_OPTIONS_SETTINGS_LANGUAGES_CANNOT_BE_DISPLAYED_IN_THIS_LANGUAGE,
  58       IDS_PRODUCT_NAME },
  59     { "isDisplayedInThisLanguage",
  60       IDS_OPTIONS_SETTINGS_LANGUAGES_IS_DISPLAYED_IN_THIS_LANGUAGE,
  61       IDS_PRODUCT_NAME },
  62     { "displayInThisLanguage",
  63       IDS_OPTIONS_SETTINGS_LANGUAGES_DISPLAY_IN_THIS_LANGUAGE,
  64       IDS_PRODUCT_NAME },
  65     { "restartRequired", IDS_OPTIONS_RELAUNCH_REQUIRED },
  66   // OS X uses the OS native spellchecker so no need for these strings.
  67 #if !defined(OS_MACOSX)
  68     { "useThisForSpellChecking",
  69       IDS_OPTIONS_SETTINGS_USE_THIS_FOR_SPELL_CHECKING },
  70     { "cannotBeUsedForSpellChecking",
  71       IDS_OPTIONS_SETTINGS_CANNOT_BE_USED_FOR_SPELL_CHECKING },
  72     { "isUsedForSpellChecking",
  73       IDS_OPTIONS_SETTINGS_IS_USED_FOR_SPELL_CHECKING },
  74     { "enableSpellCheck", IDS_OPTIONS_ENABLE_SPELLCHECK },
  75     { "enableAutoSpellCorrection",
  76       IDS_OPTIONS_ENABLE_AUTO_SPELL_CORRECTION },
  77     { "downloadingDictionary", IDS_OPTIONS_DICTIONARY_DOWNLOADING },
  78     { "downloadFailed", IDS_OPTIONS_DICTIONARY_DOWNLOAD_FAILED },
  79     { "retryButton", IDS_OPTIONS_DICTIONARY_DOWNLOAD_RETRY },
  80     { "downloadFailHelp", IDS_OPTIONS_DICTIONARY_DOWNLOAD_FAIL_HELP },
  81 #endif  // !OS_MACOSX
  82     { "addLanguageTitle", IDS_OPTIONS_LANGUAGES_ADD_TITLE },
  83     { "addLanguageSelectLabel", IDS_OPTIONS_LANGUAGES_ADD_SELECT_LABEL },
  84     { "restartButton", IDS_OPTIONS_SETTINGS_LANGUAGES_RELAUNCH_BUTTON },
  85     { "offerToTranslateInThisLanguage",
  86       IDS_OPTIONS_LANGUAGES_OFFER_TO_TRANSLATE_IN_THIS_LANGUAGE },
  87     { "cannotTranslateInThisLanguage",
  88       IDS_OPTIONS_LANGUAGES_CANNOT_TRANSLATE_IN_THIS_LANGUAGE },
  89   };
  90
  91 #if defined(ENABLE_SETTINGS_APP)
  92   static OptionsStringResource app_resources[] = {
  93     { "cannotBeDisplayedInThisLanguage",
  94       IDS_OPTIONS_SETTINGS_LANGUAGES_CANNOT_BE_DISPLAYED_IN_THIS_LANGUAGE,
  95       IDS_SETTINGS_APP_LAUNCHER_PRODUCT_NAME },
  96     { "isDisplayedInThisLanguage",
  97       IDS_OPTIONS_SETTINGS_LANGUAGES_IS_DISPLAYED_IN_THIS_LANGUAGE,
  98       IDS_SETTINGS_APP_LAUNCHER_PRODUCT_NAME },
  99     { "displayInThisLanguage",
 100       IDS_OPTIONS_SETTINGS_LANGUAGES_DISPLAY_IN_THIS_LANGUAGE,
 101       IDS_SETTINGS_APP_LAUNCHER_PRODUCT_NAME },
 102   };
 103   base::DictionaryValue* app_values = NULL;
 104   CHECK(localized_strings->GetDictionary(kSettingsAppKey, &app_values));
 105   RegisterStrings(app_values, app_resources, arraysize(app_resources));
 106 #endif
 107
 108   RegisterStrings(localized_strings, resources, arraysize(resources));
 109
 110   // The following are resources, rather than local strings.
 111   std::string application_locale = g_browser_process->GetApplicationLocale();
 112   localized_strings->SetString("currentUiLanguageCode", application_locale);
 113   std::string prospective_locale =
 114       g_browser_process->local_state()->GetString(prefs::kApplicationLocale);
 115   localized_strings->SetString("prospectiveUiLanguageCode",
 116       !prospective_locale.empty() ? prospective_locale : application_locale);
 117   localized_strings->Set("spellCheckLanguageCodeSet",
 118                          GetSpellCheckLanguageCodeSet());
 119   localized_strings->Set("uiLanguageCodeSet", GetUILanguageCodeSet());
 120
 121   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 122   bool enable_spelling_auto_correct =
 123       command_line.HasSwitch(switches::kEnableSpellingAutoCorrect);
 124   localized_strings->SetBoolean("enableSpellingAutoCorrect",
 125                                 enable_spelling_auto_correct);
 126
 127   Profile* profile = Profile::FromWebUI(web_ui());
 128   PrefService* prefs = profile->GetPrefs();
 129   std::string default_target_language =
 130       TranslateService::GetTargetLanguage(prefs);
 131   localized_strings->SetString("defaultTargetLanguage",
 132                                default_target_language);
 133
 134   std::vector<std::string> languages;
 135   translate::TranslateDownloadManager::GetSupportedLanguages(&languages);
 136
 137   base::ListValue* languages_list = new base::ListValue();
 138   for (std::vector<std::string>::iterator it = languages.begin();
 139        it != languages.end(); ++it) {
 140     languages_list->Append(new base::StringValue(*it));
 141   }
 142
 143   localized_strings->Set("translateSupportedLanguages", languages_list);
 144 }
 145
 146 void LanguageOptionsHandlerCommon::Uninitialize() {
 147   if (hunspell_dictionary_.get())
 148     hunspell_dictionary_->RemoveObserver(this);
 149   hunspell_dictionary_.reset();
 150 }
 151
 152 void LanguageOptionsHandlerCommon::RegisterMessages() {
 153   web_ui()->RegisterMessageCallback("languageOptionsOpen",
 154       base::Bind(
 155           &LanguageOptionsHandlerCommon::LanguageOptionsOpenCallback,
 156           base::Unretained(this)));
 157   web_ui()->RegisterMessageCallback("spellCheckLanguageChange",
 158       base::Bind(
 159           &LanguageOptionsHandlerCommon::SpellCheckLanguageChangeCallback,
 160           base::Unretained(this)));
 161   web_ui()->RegisterMessageCallback("uiLanguageChange",
 162       base::Bind(
 163           &LanguageOptionsHandlerCommon::UiLanguageChangeCallback,
 164           base::Unretained(this)));
 165   web_ui()->RegisterMessageCallback("retryDictionaryDownload",
 166       base::Bind(
 167           &LanguageOptionsHandlerCommon::RetrySpellcheckDictionaryDownload,
 168           base::Unretained(this)));
 169   web_ui()->RegisterMessageCallback("updateLanguageList",
 170       base::Bind(
 171           &LanguageOptionsHandlerCommon::UpdateLanguageListCallback,
 172           base::Unretained(this)));
 173 }
 174
 175 void LanguageOptionsHandlerCommon::OnHunspellDictionaryInitialized() {
 176 }
 177
 178 void LanguageOptionsHandlerCommon::OnHunspellDictionaryDownloadBegin() {
 179   web_ui()->CallJavascriptFunction(
 180       "options.LanguageOptions.onDictionaryDownloadBegin",
 181       base::StringValue(GetHunspellDictionary()->GetLanguage()));
 182 }
 183
 184 void LanguageOptionsHandlerCommon::OnHunspellDictionaryDownloadSuccess() {
 185   web_ui()->CallJavascriptFunction(
 186       "options.LanguageOptions.onDictionaryDownloadSuccess",
 187       base::StringValue(GetHunspellDictionary()->GetLanguage()));
 188 }
 189
 190 void LanguageOptionsHandlerCommon::OnHunspellDictionaryDownloadFailure() {
 191   web_ui()->CallJavascriptFunction(
 192       "options.LanguageOptions.onDictionaryDownloadFailure",
 193       base::StringValue(GetHunspellDictionary()->GetLanguage()));
 194 }
 195
 196 base::DictionaryValue* LanguageOptionsHandlerCommon::GetUILanguageCodeSet() {
 197   base::DictionaryValue* dictionary = new base::DictionaryValue();
 198   const std::vector<std::string>& available_locales =
 199       l10n_util::GetAvailableLocales();
 200   for (size_t i = 0; i < available_locales.size(); ++i)
 201     dictionary->SetBoolean(available_locales[i], true);
 202   return dictionary;
 203 }
 204
 205 base::DictionaryValue*
 206 LanguageOptionsHandlerCommon::GetSpellCheckLanguageCodeSet() {
 207   base::DictionaryValue* dictionary = new base::DictionaryValue();
 208   std::vector<std::string> spell_check_languages;
 209   chrome::spellcheck_common::SpellCheckLanguages(&spell_check_languages);
 210   for (size_t i = 0; i < spell_check_languages.size(); ++i) {
 211     dictionary->SetBoolean(spell_check_languages[i], true);
 212   }
 213   return dictionary;
 214 }
 215
 216 void LanguageOptionsHandlerCommon::LanguageOptionsOpenCallback(
 217     const base::ListValue* args) {
 218   content::RecordAction(UserMetricsAction("LanguageOptions_Open"));
 219   RefreshHunspellDictionary();
 220   if (hunspell_dictionary_->IsDownloadInProgress())
 221     OnHunspellDictionaryDownloadBegin();
 222   else if (hunspell_dictionary_->IsDownloadFailure())
 223     OnHunspellDictionaryDownloadFailure();
 224   else
 225     OnHunspellDictionaryDownloadSuccess();
 226 }
 227
 228 void LanguageOptionsHandlerCommon::UiLanguageChangeCallback(
 229     const base::ListValue* args) {
 230   const std::string language_code =
 231       base::UTF16ToASCII(ExtractStringValue(args));
 232   CHECK(!language_code.empty());
 233   const std::string action = base::StringPrintf(
 234       "LanguageOptions_UiLanguageChange_%s", language_code.c_str());
 235   content::RecordComputedAction(action);
 236   SetApplicationLocale(language_code);
 237   base::StringValue language_value(language_code);
 238   web_ui()->CallJavascriptFunction("options.LanguageOptions.uiLanguageSaved",
 239                                    language_value);
 240 }
 241
 242 void LanguageOptionsHandlerCommon::SpellCheckLanguageChangeCallback(
 243     const base::ListValue* args) {
 244   const std::string language_code =
 245       base::UTF16ToASCII(ExtractStringValue(args));
 246   CHECK(!language_code.empty());
 247   const std::string action = base::StringPrintf(
 248       "LanguageOptions_SpellCheckLanguageChange_%s", language_code.c_str());
 249   content::RecordComputedAction(action);
 250   RefreshHunspellDictionary();
 251 }
 252
 253 void LanguageOptionsHandlerCommon::UpdateLanguageListCallback(
 254     const base::ListValue* args) {
 255   CHECK_EQ(args->GetSize(), 1u);
 256   const base::ListValue* language_list;
 257   args->GetList(0, &language_list);
 258   DCHECK(language_list);
 259
 260   std::vector<std::string> languages;
 261   for (base::ListValue::const_iterator it = language_list->begin();
 262        it != language_list->end(); ++it) {
 263     std::string lang;
 264     (*it)->GetAsString(&lang);
 265     languages.push_back(lang);
 266   }
 267
 268   Profile* profile = Profile::FromWebUI(web_ui());
 269   scoped_ptr<translate::TranslatePrefs> translate_prefs =
 270       ChromeTranslateClient::CreateTranslatePrefs(profile->GetPrefs());
 271   translate_prefs->UpdateLanguageList(languages);
 272 }
 273
 274 void LanguageOptionsHandlerCommon::RetrySpellcheckDictionaryDownload(
 275     const base::ListValue* args) {
 276   GetHunspellDictionary()->RetryDownloadDictionary(
 277       Profile::FromWebUI(web_ui())->GetRequestContext());
 278 }
 279
 280 void LanguageOptionsHandlerCommon::RefreshHunspellDictionary() {
 281   if (hunspell_dictionary_.get())
 282     hunspell_dictionary_->RemoveObserver(this);
 283   hunspell_dictionary_.reset();
 284   SpellcheckService* service = SpellcheckServiceFactory::GetForContext(
 285       Profile::FromWebUI(web_ui()));
 286   hunspell_dictionary_ = service->GetHunspellDictionary()->AsWeakPtr();
 287   hunspell_dictionary_->AddObserver(this);
 288 }
 289
 290 base::WeakPtr<SpellcheckHunspellDictionary>&
 291     LanguageOptionsHandlerCommon::GetHunspellDictionary() {
 292   if (!hunspell_dictionary_.get())
 293     RefreshHunspellDictionary();
 294   return hunspell_dictionary_;
 295 }
 296
 297 }  // namespace options