Implement the 2016Q2 Translate UI designe spec out in

components/translate/core/browser/translate_prefs.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/translate/core/browser/translate_prefs.h"
 
 #include <set>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/translate/core/browser/translate_accept_languages.h"
 #include "components/translate/core/browser/translate_download_manager.h"
 #include "components/translate/core/browser/translate_experiment.h"
 #include "components/translate/core/common/translate_util.h"
 
 namespace translate {
 
 const char TranslatePrefs::kPrefTranslateSiteBlacklist[] =
     "translate_site_blacklist";
-const char TranslatePrefs::kPrefTranslateWhitelists[] =
-    "translate_whitelists";
+const char TranslatePrefs::kPrefTranslateWhitelists[] = "translate_whitelists";
 const char TranslatePrefs::kPrefTranslateDeniedCount[] =
     "translate_denied_count_for_language";
+const char TranslatePrefs::kPrefTranslateIgnoredCount[] =
+    "translate_ignored_count_for_language";
 const char TranslatePrefs::kPrefTranslateAcceptedCount[] =
     "translate_accepted_count";
 const char TranslatePrefs::kPrefTranslateBlockedLanguages[] =
     "translate_blocked_languages";
 const char TranslatePrefs::kPrefTranslateLastDeniedTimeForLanguage[] =
     "translate_last_denied_time_for_language";
 const char TranslatePrefs::kPrefTranslateTooOftenDeniedForLanguage[] =
     "translate_too_often_denied_for_language";
 
 // This property is deprecated but there is still some usages. Don't use this
 // for new code.
 static const char kPrefTranslateLanguageBlacklist[] =
     "translate_language_blacklist";
 
 // The below properties used to be used but now are deprecated. Don't use them
 // since an old profile might have some values there.
 //
 // * translate_last_denied_time
 // * translate_too_often_denied
 
 namespace {
 
 void GetBlacklistedLanguages(const PrefService* prefs,
                              std::vector<std::string>* languages) {
   DCHECK(languages);
   DCHECK(languages->empty());
 
   const char* key = kPrefTranslateLanguageBlacklist;
   const base::ListValue* list = prefs->GetList(key);
-  for (base::ListValue::const_iterator it = list->begin();
-       it != list->end(); ++it) {
+  for (base::ListValue::const_iterator it = list->begin(); it != list->end();
+       ++it) {
     std::string lang;
     (*it)->GetAsString(&lang);
     languages->push_back(lang);
   }
 }
 
 // Expands language codes to make these more suitable for Accept-Language.
 // Example: ['en-US', 'ja', 'en-CA'] => ['en-US', 'en', 'ja', 'en-CA'].
 // 'en' won't appear twice as this function eliminates duplicates.
 void ExpandLanguageCodes(const std::vector<std::string>& languages,
@@ skipping 19 matching lines @@
     const std::string& main_part = tokens[0];
     if (seen.find(main_part) == seen.end()) {
       expanded_languages->push_back(main_part);
       seen.insert(main_part);
     }
   }
 }
 
 }  // namespace
 
+const base::Feature kTranslateUI2016Q2{"TranslateUI2016Q2",
+                                       base::FEATURE_DISABLED_BY_DEFAULT};
+
 DenialTimeUpdate::DenialTimeUpdate(PrefService* prefs,
                                    const std::string& language,
                                    size_t max_denial_count)
     : denial_time_dict_update_(
           prefs,
           TranslatePrefs::kPrefTranslateLastDeniedTimeForLanguage),
       language_(language),
       max_denial_count_(max_denial_count),
       time_list_(nullptr) {}
 
@@ skipping 37 matching lines @@
   DCHECK(GetDenialTimes());
   GetDenialTimes()->AppendDouble(denial_time.ToJsTime());
 
   while (GetDenialTimes()->GetSize() >= max_denial_count_)
     GetDenialTimes()->Remove(0, nullptr);
 }
 
 TranslatePrefs::TranslatePrefs(PrefService* user_prefs,
                                const char* accept_languages_pref,
                                const char* preferred_languages_pref)
-    : accept_languages_pref_(accept_languages_pref),
-      prefs_(user_prefs) {
+    : accept_languages_pref_(accept_languages_pref), prefs_(user_prefs) {
 #if defined(OS_CHROMEOS)
   preferred_languages_pref_ = preferred_languages_pref;
 #else
   DCHECK(!preferred_languages_pref);
 #endif
 }
 
 void TranslatePrefs::SetCountry(const std::string& country) {
   country_ = country;
 }
 
 std::string TranslatePrefs::GetCountry() const {
   return country_;
 }
 
 void TranslatePrefs::ResetToDefaults() {
   ClearBlockedLanguages();
   ClearBlacklistedSites();
   ClearWhitelistedLanguagePairs();
 
   std::vector<std::string> languages;
   GetLanguageList(&languages);
   for (std::vector<std::string>::const_iterator it = languages.begin();
-      it != languages.end(); ++it) {
+       it != languages.end(); ++it) {
     const std::string& language = *it;
     ResetTranslationAcceptedCount(language);
     ResetTranslationDeniedCount(language);
+    ResetTranslationIgnoredCount(language);
   }
 
   prefs_->ClearPref(kPrefTranslateLastDeniedTimeForLanguage);
   prefs_->ClearPref(kPrefTranslateTooOftenDeniedForLanguage);
 }
 
 bool TranslatePrefs::IsBlockedLanguage(
     const std::string& original_language) const {
-  return IsValueBlacklisted(kPrefTranslateBlockedLanguages,
-                            original_language);
+  return IsValueBlacklisted(kPrefTranslateBlockedLanguages, original_language);
 }
 
 void TranslatePrefs::BlockLanguage(const std::string& original_language) {
   BlacklistValue(kPrefTranslateBlockedLanguages, original_language);
 
   // Add the language to the language list at chrome://settings/languages.
   std::string language = original_language;
   translate::ToChromeLanguageSynonym(&language);
 
   std::vector<std::string> languages;
@@ skipping 104 matching lines @@
   int count = 0;
   dict->GetInteger(language, &count);
   dict->SetInteger(language, count + 1);
 }
 
 void TranslatePrefs::ResetTranslationDeniedCount(const std::string& language) {
   DictionaryPrefUpdate update(prefs_, kPrefTranslateDeniedCount);
   update.Get()->SetInteger(language, 0);
 }
 
+int TranslatePrefs::GetTranslationIgnoredCount(
+    const std::string& language) const {
+  const base::DictionaryValue* dict =
+      prefs_->GetDictionary(kPrefTranslateIgnoredCount);
+  int count = 0;
+  return dict->GetInteger(language, &count) ? count : 0;
+}
+
+void TranslatePrefs::IncrementTranslationIgnoredCount(
+    const std::string& language) {
+  DictionaryPrefUpdate update(prefs_, kPrefTranslateIgnoredCount);
+  base::DictionaryValue* dict = update.Get();
+
+  int count = 0;
+  dict->GetInteger(language, &count);
+  dict->SetInteger(language, count + 1);
+}
+
+void TranslatePrefs::ResetTranslationIgnoredCount(const std::string& language) {
+  DictionaryPrefUpdate update(prefs_, kPrefTranslateIgnoredCount);
+  update.Get()->SetInteger(language, 0);
+}
+
 int TranslatePrefs::GetTranslationAcceptedCount(const std::string& language) {
   const base::DictionaryValue* dict =
       prefs_->GetDictionary(kPrefTranslateAcceptedCount);
   int count = 0;
   return dict->GetInteger(language, &count) ? count : 0;
 }
 
 void TranslatePrefs::IncrementTranslationAcceptedCount(
     const std::string& language) {
   DictionaryPrefUpdate update(prefs_, kPrefTranslateAcceptedCount);
@@ skipping 22 matching lines @@
     return;
 
   if (now - oldest_denial_time <= base::TimeDelta::FromDays(1)) {
     DictionaryPrefUpdate update(prefs_,
                                 kPrefTranslateTooOftenDeniedForLanguage);
     update.Get()->SetBoolean(language, true);
   }
 }
 
 bool TranslatePrefs::IsTooOftenDenied(const std::string& language) const {
-  const base::DictionaryValue* dict =
-    prefs_->GetDictionary(kPrefTranslateTooOftenDeniedForLanguage);
-  bool result = false;
-  return dict->GetBoolean(language, &result) ? result : false;
+  if (base::FeatureList::IsEnabled(kTranslateUI2016Q2)) {
+    // In the new logic, we only hide the bubble if user denied it more than
+    // 3 times or the user ignored more than 10 times.

[msw, 2016/04/29 23:43:40]

nit: 'ignored it'

[ftang, 2016/04/30 01:24:50]

Done.

+    return (GetTranslationDeniedCount(language) > 3) ||
+           (GetTranslationIgnoredCount(language) > 10);
+  } else {
+    const base::DictionaryValue* dict =
+        prefs_->GetDictionary(kPrefTranslateTooOftenDeniedForLanguage);
+    bool result = false;
+    return dict->GetBoolean(language, &result) ? result : false;
+  }
 }
 
 void TranslatePrefs::ResetDenialState() {
   prefs_->ClearPref(kPrefTranslateLastDeniedTimeForLanguage);
   prefs_->ClearPref(kPrefTranslateTooOftenDeniedForLanguage);
 }
 
 void TranslatePrefs::GetLanguageList(
     std::vector<std::string>* languages) const {
   DCHECK(languages);
@@ skipping 71 matching lines @@
                              user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterListPref(kPrefTranslateSiteBlacklist,
                              user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterDictionaryPref(
       kPrefTranslateWhitelists,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterDictionaryPref(
       kPrefTranslateDeniedCount,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterDictionaryPref(
+      kPrefTranslateIgnoredCount,
+      user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
+  registry->RegisterDictionaryPref(
       kPrefTranslateAcceptedCount,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterListPref(kPrefTranslateBlockedLanguages,
                              user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterDictionaryPref(kPrefTranslateLastDeniedTimeForLanguage);
   registry->RegisterDictionaryPref(
       kPrefTranslateTooOftenDeniedForLanguage,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 }
 
@@ skipping 44 matching lines @@
   // should be translated instead of the blacklist. The blacklist is no longer
   // used after launching the settings UI.
   // After that, Set 'translate_languages_not_translate' to Accept languages to
   // enable settings for users.
   bool merged = user_prefs->HasPrefPath(kPrefTranslateBlockedLanguages);
 
   if (!merged) {
     std::vector<std::string> blacklisted_languages;
     GetBlacklistedLanguages(user_prefs, &blacklisted_languages);
 
-    std::vector<std::string> accept_languages = base::SplitString(
-        user_prefs->GetString(accept_languages_pref), ",",
-        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+    std::vector<std::string> accept_languages =
+        base::SplitString(user_prefs->GetString(accept_languages_pref), ",",
+                          base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
     std::vector<std::string> blocked_languages;
-    CreateBlockedLanguages(
-        &blocked_languages, blacklisted_languages, accept_languages);
+    CreateBlockedLanguages(&blocked_languages, blacklisted_languages,
+                           accept_languages);
 
     // Create the new preference kPrefTranslateBlockedLanguages.
     {
       base::ListValue blocked_languages_list;
       for (std::vector<std::string>::const_iterator it =
                blocked_languages.begin();
            it != blocked_languages.end(); ++it) {
         blocked_languages_list.Append(new base::StringValue(*it));
       }
       ListPrefUpdate update(user_prefs, kPrefTranslateBlockedLanguages);
@@ skipping 50 matching lines @@
     translate::ToTranslateLanguageSynonym(&lang);
 
     // Regarding http://crbug.com/36182, even though English exists in Accept
     // language list, English could be translated on non-English locale.
     if (lang == "en" && !is_ui_english)
       continue;
 
     result.insert(lang);
   }
 
-  blocked_languages->insert(
-      blocked_languages->begin(), result.begin(), result.end());
+  blocked_languages->insert(blocked_languages->begin(), result.begin(),
+                            result.end());
 }
 
 bool TranslatePrefs::IsValueInList(const base::ListValue* list,
                                    const std::string& in_value) const {
   for (size_t i = 0; i < list->GetSize(); ++i) {
     std::string value;
     if (list->GetString(i, &value) && value == in_value)
       return true;
   }
   return false;
@@ skipping 34 matching lines @@
   const base::ListValue* blacklist = prefs_->GetList(pref_id);
   return (blacklist == NULL || blacklist->empty());
 }
 
 bool TranslatePrefs::IsDictionaryEmpty(const char* pref_id) const {
   const base::DictionaryValue* dict = prefs_->GetDictionary(pref_id);
   return (dict == NULL || dict->empty());
 }
 
 }  // namespace translate