Home | History | Annotate | Download | only in browser 
      1 // Copyright 2014 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 "components/translate/core/browser/translate_prefs.h"
      6 
      7 #include <set>
      8 
      9 #include "base/prefs/pref_service.h"
     10 #include "base/prefs/scoped_user_pref_update.h"
     11 #include "base/strings/string_split.h"
     12 #include "base/strings/string_util.h"
     13 #include "components/pref_registry/pref_registry_syncable.h"
     14 #include "components/translate/core/browser/translate_accept_languages.h"
     15 #include "components/translate/core/browser/translate_download_manager.h"
     16 #include "components/translate/core/common/translate_util.h"
     17 
     18 namespace translate {
     19 
     20 const char TranslatePrefs::kPrefTranslateLanguageBlacklist[] =
     21     "translate_language_blacklist";
     22 const char TranslatePrefs::kPrefTranslateSiteBlacklist[] =
     23     "translate_site_blacklist";
     24 const char TranslatePrefs::kPrefTranslateWhitelists[] =
     25     "translate_whitelists";
     26 const char TranslatePrefs::kPrefTranslateDeniedCount[] =
     27     "translate_denied_count";
     28 const char TranslatePrefs::kPrefTranslateAcceptedCount[] =
     29     "translate_accepted_count";
     30 const char TranslatePrefs::kPrefTranslateBlockedLanguages[] =
     31     "translate_blocked_languages";
     32 const char TranslatePrefs::kPrefTranslateLastDeniedTime[] =
     33     "translate_last_denied_time";
     34 const char TranslatePrefs::kPrefTranslateTooOftenDenied[] =
     35     "translate_too_often_denied";
     36 
     37 namespace {
     38 
     39 void GetBlacklistedLanguages(const PrefService* prefs,
     40                              std::vector<std::string>* languages) {
     41   DCHECK(languages);
     42   DCHECK(languages->empty());
     43 
     44   const char* key = TranslatePrefs::kPrefTranslateLanguageBlacklist;
     45   const base::ListValue* list = prefs->GetList(key);
     46   for (base::ListValue::const_iterator it = list->begin();
     47        it != list->end(); ++it) {
     48     std::string lang;
     49     (*it)->GetAsString(&lang);
     50     languages->push_back(lang);
     51   }
     52 }
     53 
     54 // Expands language codes to make these more suitable for Accept-Language.
     55 // Example: ['en-US', 'ja', 'en-CA'] => ['en-US', 'en', 'ja', 'en-CA'].
     56 // 'en' won't appear twice as this function eliminates duplicates.
     57 void ExpandLanguageCodes(const std::vector<std::string>& languages,
     58                          std::vector<std::string>* expanded_languages) {
     59   DCHECK(expanded_languages);
     60   DCHECK(expanded_languages->empty());
     61 
     62   // used to eliminate duplicates.
     63   std::set<std::string> seen;
     64 
     65   for (std::vector<std::string>::const_iterator it = languages.begin();
     66        it != languages.end(); ++it) {
     67     const std::string& language = *it;
     68     if (seen.find(language) == seen.end()) {
     69       expanded_languages->push_back(language);
     70       seen.insert(language);
     71     }
     72 
     73     std::vector<std::string> tokens;
     74     base::SplitString(language, '-', &tokens);
     75     if (tokens.size() == 0)
     76       continue;
     77     const std::string& main_part = tokens[0];
     78     if (seen.find(main_part) == seen.end()) {
     79       expanded_languages->push_back(main_part);
     80       seen.insert(main_part);
     81     }
     82   }
     83 }
     84 
     85 }  // namespace
     86 
     87 TranslatePrefs::TranslatePrefs(PrefService* user_prefs,
     88                                const char* accept_languages_pref,
     89                                const char* preferred_languages_pref)
     90     : accept_languages_pref_(accept_languages_pref),
     91       prefs_(user_prefs) {
     92 #if defined(OS_CHROMEOS)
     93   preferred_languages_pref_ = preferred_languages_pref;
     94 #else
     95   DCHECK(!preferred_languages_pref);
     96 #endif
     97 }
     98 
     99 void TranslatePrefs::ResetToDefaults() {
    100   ClearBlockedLanguages();
    101   ClearBlacklistedSites();
    102   ClearWhitelistedLanguagePairs();
    103 
    104   std::vector<std::string> languages;
    105   GetLanguageList(&languages);
    106   for (std::vector<std::string>::const_iterator it = languages.begin();
    107       it != languages.end(); ++it) {
    108     const std::string& language = *it;
    109     ResetTranslationAcceptedCount(language);
    110     ResetTranslationDeniedCount(language);
    111   }
    112 
    113   prefs_->ClearPref(kPrefTranslateLastDeniedTime);
    114   prefs_->ClearPref(kPrefTranslateTooOftenDenied);
    115 }
    116 
    117 bool TranslatePrefs::IsBlockedLanguage(
    118     const std::string& original_language) const {
    119   return IsValueBlacklisted(kPrefTranslateBlockedLanguages,
    120                             original_language);
    121 }
    122 
    123 void TranslatePrefs::BlockLanguage(const std::string& original_language) {
    124   BlacklistValue(kPrefTranslateBlockedLanguages, original_language);
    125 
    126   // Add the language to the language list at chrome://settings/languages.
    127   std::string language = original_language;
    128   translate::ToChromeLanguageSynonym(&language);
    129 
    130   std::vector<std::string> languages;
    131   GetLanguageList(&languages);
    132 
    133   if (std::find(languages.begin(), languages.end(), language) ==
    134       languages.end()) {
    135     languages.push_back(language);
    136     UpdateLanguageList(languages);
    137   }
    138 }
    139 
    140 void TranslatePrefs::UnblockLanguage(const std::string& original_language) {
    141   RemoveValueFromBlacklist(kPrefTranslateBlockedLanguages, original_language);
    142 }
    143 
    144 void TranslatePrefs::RemoveLanguageFromLegacyBlacklist(
    145     const std::string& original_language) {
    146   RemoveValueFromBlacklist(kPrefTranslateLanguageBlacklist, original_language);
    147 }
    148 
    149 bool TranslatePrefs::IsSiteBlacklisted(const std::string& site) const {
    150   return IsValueBlacklisted(kPrefTranslateSiteBlacklist, site);
    151 }
    152 
    153 void TranslatePrefs::BlacklistSite(const std::string& site) {
    154   BlacklistValue(kPrefTranslateSiteBlacklist, site);
    155 }
    156 
    157 void TranslatePrefs::RemoveSiteFromBlacklist(const std::string& site) {
    158   RemoveValueFromBlacklist(kPrefTranslateSiteBlacklist, site);
    159 }
    160 
    161 bool TranslatePrefs::IsLanguagePairWhitelisted(
    162     const std::string& original_language,
    163     const std::string& target_language) {
    164   const base::DictionaryValue* dict =
    165       prefs_->GetDictionary(kPrefTranslateWhitelists);
    166   if (dict && !dict->empty()) {
    167     std::string auto_target_lang;
    168     if (dict->GetString(original_language, &auto_target_lang) &&
    169         auto_target_lang == target_language)
    170       return true;
    171   }
    172   return false;
    173 }
    174 
    175 void TranslatePrefs::WhitelistLanguagePair(const std::string& original_language,
    176                                            const std::string& target_language) {
    177   DictionaryPrefUpdate update(prefs_, kPrefTranslateWhitelists);
    178   base::DictionaryValue* dict = update.Get();
    179   if (!dict) {
    180     NOTREACHED() << "Unregistered translate whitelist pref";
    181     return;
    182   }
    183   dict->SetString(original_language, target_language);
    184 }
    185 
    186 void TranslatePrefs::RemoveLanguagePairFromWhitelist(
    187     const std::string& original_language,
    188     const std::string& target_language) {
    189   DictionaryPrefUpdate update(prefs_, kPrefTranslateWhitelists);
    190   base::DictionaryValue* dict = update.Get();
    191   if (!dict) {
    192     NOTREACHED() << "Unregistered translate whitelist pref";
    193     return;
    194   }
    195   dict->Remove(original_language, NULL);
    196 }
    197 
    198 bool TranslatePrefs::HasBlockedLanguages() const {
    199   return !IsListEmpty(kPrefTranslateBlockedLanguages);
    200 }
    201 
    202 void TranslatePrefs::ClearBlockedLanguages() {
    203   prefs_->ClearPref(kPrefTranslateBlockedLanguages);
    204 }
    205 
    206 bool TranslatePrefs::HasBlacklistedSites() const {
    207   return !IsListEmpty(kPrefTranslateSiteBlacklist);
    208 }
    209 
    210 void TranslatePrefs::ClearBlacklistedSites() {
    211   prefs_->ClearPref(kPrefTranslateSiteBlacklist);
    212 }
    213 
    214 bool TranslatePrefs::HasWhitelistedLanguagePairs() const {
    215   return !IsDictionaryEmpty(kPrefTranslateWhitelists);
    216 }
    217 
    218 void TranslatePrefs::ClearWhitelistedLanguagePairs() {
    219   prefs_->ClearPref(kPrefTranslateWhitelists);
    220 }
    221 
    222 int TranslatePrefs::GetTranslationDeniedCount(
    223     const std::string& language) const {
    224   const base::DictionaryValue* dict =
    225       prefs_->GetDictionary(kPrefTranslateDeniedCount);
    226   int count = 0;
    227   return dict->GetInteger(language, &count) ? count : 0;
    228 }
    229 
    230 void TranslatePrefs::IncrementTranslationDeniedCount(
    231     const std::string& language) {
    232   DictionaryPrefUpdate update(prefs_, kPrefTranslateDeniedCount);
    233   base::DictionaryValue* dict = update.Get();
    234 
    235   int count = 0;
    236   dict->GetInteger(language, &count);
    237   dict->SetInteger(language, count + 1);
    238 }
    239 
    240 void TranslatePrefs::ResetTranslationDeniedCount(const std::string& language) {
    241   DictionaryPrefUpdate update(prefs_, kPrefTranslateDeniedCount);
    242   update.Get()->SetInteger(language, 0);
    243 }
    244 
    245 int TranslatePrefs::GetTranslationAcceptedCount(const std::string& language) {
    246   const base::DictionaryValue* dict =
    247       prefs_->GetDictionary(kPrefTranslateAcceptedCount);
    248   int count = 0;
    249   return dict->GetInteger(language, &count) ? count : 0;
    250 }
    251 
    252 void TranslatePrefs::IncrementTranslationAcceptedCount(
    253     const std::string& language) {
    254   DictionaryPrefUpdate update(prefs_, kPrefTranslateAcceptedCount);
    255   base::DictionaryValue* dict = update.Get();
    256   int count = 0;
    257   dict->GetInteger(language, &count);
    258   dict->SetInteger(language, count + 1);
    259 }
    260 
    261 void TranslatePrefs::ResetTranslationAcceptedCount(
    262     const std::string& language) {
    263   DictionaryPrefUpdate update(prefs_, kPrefTranslateAcceptedCount);
    264   update.Get()->SetInteger(language, 0);
    265 }
    266 
    267 void TranslatePrefs::UpdateLastDeniedTime() {
    268   if (IsTooOftenDenied())
    269     return;
    270 
    271   double time = prefs_->GetDouble(kPrefTranslateLastDeniedTime);
    272   base::Time last_closed_time = base::Time::FromJsTime(time);
    273   base::Time now = base::Time::Now();
    274   prefs_->SetDouble(kPrefTranslateLastDeniedTime, now.ToJsTime());
    275   if (now - last_closed_time <= base::TimeDelta::FromDays(1))
    276     prefs_->SetBoolean(kPrefTranslateTooOftenDenied, true);
    277 }
    278 
    279 bool TranslatePrefs::IsTooOftenDenied() const {
    280   return prefs_->GetBoolean(kPrefTranslateTooOftenDenied);
    281 }
    282 
    283 void TranslatePrefs::ResetDenialState() {
    284   prefs_->SetDouble(kPrefTranslateLastDeniedTime, 0);
    285   prefs_->SetBoolean(kPrefTranslateTooOftenDenied, false);
    286 }
    287 
    288 void TranslatePrefs::GetLanguageList(std::vector<std::string>* languages) {
    289   DCHECK(languages);
    290   DCHECK(languages->empty());
    291 
    292 #if defined(OS_CHROMEOS)
    293   const char* key = preferred_languages_pref_.c_str();
    294 #else
    295   const char* key = accept_languages_pref_.c_str();
    296 #endif
    297 
    298   std::string languages_str = prefs_->GetString(key);
    299   base::SplitString(languages_str, ',', languages);
    300 }
    301 
    302 void TranslatePrefs::UpdateLanguageList(
    303     const std::vector<std::string>& languages) {
    304 #if defined(OS_CHROMEOS)
    305   std::string languages_str = JoinString(languages, ',');
    306   prefs_->SetString(preferred_languages_pref_.c_str(), languages_str);
    307 #endif
    308 
    309   // Save the same language list as accept languages preference as well, but we
    310   // need to expand the language list, to make it more acceptable. For instance,
    311   // some web sites don't understand 'en-US' but 'en'. See crosbug.com/9884.
    312   std::vector<std::string> accept_languages;
    313   ExpandLanguageCodes(languages, &accept_languages);
    314   std::string accept_languages_str = JoinString(accept_languages, ',');
    315   prefs_->SetString(accept_languages_pref_.c_str(), accept_languages_str);
    316 }
    317 
    318 bool TranslatePrefs::CanTranslateLanguage(
    319     TranslateAcceptLanguages* accept_languages,
    320     const std::string& language) {
    321   bool can_be_accept_language =
    322       TranslateAcceptLanguages::CanBeAcceptLanguage(language);
    323   bool is_accept_language = accept_languages->IsAcceptLanguage(language);
    324 
    325   // Don't translate any user black-listed languages. Checking
    326   // |is_accept_language| is necessary because if the user eliminates the
    327   // language from the preference, it is natural to forget whether or not
    328   // the language should be translated. Checking |cannot_be_accept_language|
    329   // is also necessary because some minor languages can't be selected in the
    330   // language preference even though the language is available in Translate
    331   // server.
    332   if (IsBlockedLanguage(language) &&
    333       (is_accept_language || !can_be_accept_language))
    334     return false;
    335 
    336   return true;
    337 }
    338 
    339 bool TranslatePrefs::ShouldAutoTranslate(const std::string& original_language,
    340                                          std::string* target_language) {
    341   const base::DictionaryValue* dict =
    342       prefs_->GetDictionary(kPrefTranslateWhitelists);
    343   if (dict && dict->GetString(original_language, target_language)) {
    344     DCHECK(!target_language->empty());
    345     return !target_language->empty();
    346   }
    347   return false;
    348 }
    349 
    350 // static
    351 void TranslatePrefs::RegisterProfilePrefs(
    352     user_prefs::PrefRegistrySyncable* registry) {
    353   registry->RegisterListPref(kPrefTranslateLanguageBlacklist,
    354                              user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
    355   registry->RegisterListPref(kPrefTranslateSiteBlacklist,
    356                              user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
    357   registry->RegisterDictionaryPref(
    358       kPrefTranslateWhitelists,
    359       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
    360   registry->RegisterDictionaryPref(
    361       kPrefTranslateDeniedCount,
    362       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
    363   registry->RegisterDictionaryPref(
    364       kPrefTranslateAcceptedCount,
    365       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
    366   registry->RegisterListPref(kPrefTranslateBlockedLanguages,
    367                              user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
    368   registry->RegisterDoublePref(
    369       kPrefTranslateLastDeniedTime, 0,
    370       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
    371   registry->RegisterBooleanPref(
    372       kPrefTranslateTooOftenDenied, false,
    373       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
    374 }
    375 
    376 // static
    377 void TranslatePrefs::MigrateUserPrefs(PrefService* user_prefs,
    378                                       const char* accept_languages_pref) {
    379   // Old format of kPrefTranslateWhitelists
    380   // - original language -> list of target langs to auto-translate
    381   // - list of langs is in order of being enabled i.e. last in list is the
    382   //   most recent language that user enabled via
    383   //   Always translate |source_lang| to |target_lang|"
    384   // - this results in a one-to-n relationship between source lang and target
    385   //   langs.
    386   // New format:
    387   // - original language -> one target language to auto-translate
    388   // - each time that the user enables the "Always translate..." option, that
    389   //   target lang overwrites the previous one.
    390   // - this results in a one-to-one relationship between source lang and target
    391   //   lang
    392   // - we replace old list of target langs with the last target lang in list,
    393   //   assuming the last (i.e. most recent) target lang is what user wants to
    394   //   keep auto-translated.
    395   DictionaryPrefUpdate update(user_prefs, kPrefTranslateWhitelists);
    396   base::DictionaryValue* dict = update.Get();
    397   if (dict && !dict->empty()) {
    398     base::DictionaryValue::Iterator iter(*dict);
    399     while (!iter.IsAtEnd()) {
    400       const base::ListValue* list = NULL;
    401       if (!iter.value().GetAsList(&list) || !list)
    402         break;  // Dictionary has either been migrated or new format.
    403       std::string key = iter.key();
    404       // Advance the iterator before removing the current element.
    405       iter.Advance();
    406       std::string target_lang;
    407       if (list->empty() ||
    408           !list->GetString(list->GetSize() - 1, &target_lang) ||
    409           target_lang.empty()) {
    410         dict->Remove(key, NULL);
    411       } else {
    412         dict->SetString(key, target_lang);
    413       }
    414     }
    415   }
    416 
    417   // Get the union of the blacklist and the Accept languages, and set this to
    418   // the new language set 'translate_blocked_languages'. This is used for the
    419   // settings UI for Translate and configration to determine which langauage
    420   // should be translated instead of the blacklist. The blacklist is no longer
    421   // used after launching the settings UI.
    422   // After that, Set 'translate_languages_not_translate' to Accept languages to
    423   // enable settings for users.
    424   bool merged = user_prefs->HasPrefPath(kPrefTranslateBlockedLanguages);
    425 
    426   if (!merged) {
    427     std::vector<std::string> blacklisted_languages;
    428     GetBlacklistedLanguages(user_prefs, &blacklisted_languages);
    429 
    430     std::string accept_languages_str =
    431         user_prefs->GetString(accept_languages_pref);
    432     std::vector<std::string> accept_languages;
    433     base::SplitString(accept_languages_str, ',', &accept_languages);
    434 
    435     std::vector<std::string> blocked_languages;
    436     CreateBlockedLanguages(
    437         &blocked_languages, blacklisted_languages, accept_languages);
    438 
    439     // Create the new preference kPrefTranslateBlockedLanguages.
    440     {
    441       base::ListValue blocked_languages_list;
    442       for (std::vector<std::string>::const_iterator it =
    443                blocked_languages.begin();
    444            it != blocked_languages.end(); ++it) {
    445         blocked_languages_list.Append(new base::StringValue(*it));
    446       }
    447       ListPrefUpdate update(user_prefs, kPrefTranslateBlockedLanguages);
    448       base::ListValue* list = update.Get();
    449       DCHECK(list != NULL);
    450       list->Swap(&blocked_languages_list);
    451     }
    452 
    453     // Update kAcceptLanguages
    454     for (std::vector<std::string>::const_iterator it =
    455              blocked_languages.begin();
    456          it != blocked_languages.end(); ++it) {
    457       std::string lang = *it;
    458       translate::ToChromeLanguageSynonym(&lang);
    459       bool not_found =
    460           std::find(accept_languages.begin(), accept_languages.end(), lang) ==
    461           accept_languages.end();
    462       if (not_found)
    463         accept_languages.push_back(lang);
    464     }
    465 
    466     std::string new_accept_languages_str = JoinString(accept_languages, ",");
    467     user_prefs->SetString(accept_languages_pref, new_accept_languages_str);
    468   }
    469 }
    470 
    471 // static
    472 void TranslatePrefs::CreateBlockedLanguages(
    473     std::vector<std::string>* blocked_languages,
    474     const std::vector<std::string>& blacklisted_languages,
    475     const std::vector<std::string>& accept_languages) {
    476   DCHECK(blocked_languages);
    477   DCHECK(blocked_languages->empty());
    478 
    479   std::set<std::string> result;
    480 
    481   for (std::vector<std::string>::const_iterator it =
    482            blacklisted_languages.begin();
    483        it != blacklisted_languages.end(); ++it) {
    484     result.insert(*it);
    485   }
    486 
    487   const std::string& app_locale =
    488       TranslateDownloadManager::GetInstance()->application_locale();
    489   std::string ui_lang = TranslateDownloadManager::GetLanguageCode(app_locale);
    490   bool is_ui_english = ui_lang == "en" ||
    491       StartsWithASCII(ui_lang, "en-", false);
    492 
    493   for (std::vector<std::string>::const_iterator it = accept_languages.begin();
    494        it != accept_languages.end(); ++it) {
    495     std::string converted_lang = ConvertLangCodeForTranslation(*it);
    496 
    497     // Regarding http://crbug.com/36182, even though English exists in Accept
    498     // language list, English could be translated on non-English locale.
    499     if (converted_lang == "en" && !is_ui_english)
    500       continue;
    501 
    502     result.insert(converted_lang);
    503   }
    504 
    505   blocked_languages->insert(
    506       blocked_languages->begin(), result.begin(), result.end());
    507 }
    508 
    509 // static
    510 std::string TranslatePrefs::ConvertLangCodeForTranslation(
    511     const std::string& lang) {
    512   std::vector<std::string> tokens;
    513   base::SplitString(lang, '-', &tokens);
    514   if (tokens.size() < 1)
    515     return lang;
    516 
    517   std::string main_part = tokens[0];
    518 
    519   // Translate doesn't support General Chinese and the sub code is necessary.
    520   if (main_part == "zh")
    521     return lang;
    522 
    523   translate::ToTranslateLanguageSynonym(&main_part);
    524   return main_part;
    525 }
    526 
    527 bool TranslatePrefs::IsValueInList(const base::ListValue* list,
    528                                    const std::string& in_value) const {
    529   for (size_t i = 0; i < list->GetSize(); ++i) {
    530     std::string value;
    531     if (list->GetString(i, &value) && value == in_value)
    532       return true;
    533   }
    534   return false;
    535 }
    536 
    537 bool TranslatePrefs::IsValueBlacklisted(const char* pref_id,
    538                                         const std::string& value) const {
    539   const base::ListValue* blacklist = prefs_->GetList(pref_id);
    540   return (blacklist && !blacklist->empty() && IsValueInList(blacklist, value));
    541 }
    542 
    543 void TranslatePrefs::BlacklistValue(const char* pref_id,
    544                                     const std::string& value) {
    545   {
    546     ListPrefUpdate update(prefs_, pref_id);
    547     base::ListValue* blacklist = update.Get();
    548     if (!blacklist) {
    549       NOTREACHED() << "Unregistered translate blacklist pref";
    550       return;
    551     }
    552     blacklist->Append(new base::StringValue(value));
    553   }
    554 }
    555 
    556 void TranslatePrefs::RemoveValueFromBlacklist(const char* pref_id,
    557                                               const std::string& value) {
    558   ListPrefUpdate update(prefs_, pref_id);
    559   base::ListValue* blacklist = update.Get();
    560   if (!blacklist) {
    561     NOTREACHED() << "Unregistered translate blacklist pref";
    562     return;
    563   }
    564   base::StringValue string_value(value);
    565   blacklist->Remove(string_value, NULL);
    566 }
    567 
    568 bool TranslatePrefs::IsListEmpty(const char* pref_id) const {
    569   const base::ListValue* blacklist = prefs_->GetList(pref_id);
    570   return (blacklist == NULL || blacklist->empty());
    571 }
    572 
    573 bool TranslatePrefs::IsDictionaryEmpty(const char* pref_id) const {
    574   const base::DictionaryValue* dict = prefs_->GetDictionary(pref_id);
    575   return (dict == NULL || dict->empty());
    576 }
    577 
    578 }  // namespace translate
    579