Auto-always/never can at most triggered twice (new translate infobar)

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 <utility>
 
 #include "base/memory/ptr_util.h"
@@ skipping 27 matching lines @@
     "translate_blocked_languages";
 const char TranslatePrefs::kPrefTranslateLastDeniedTimeForLanguage[] =
     "translate_last_denied_time_for_language";
 const char TranslatePrefs::kPrefTranslateTooOftenDeniedForLanguage[] =
     "translate_too_often_denied_for_language";
 
 const char kTranslateUI2016Q2TrialName[] = "TranslateUI2016Q2";
 const char kAlwaysTranslateOfferThreshold[] =
     "always_translate_offer_threshold";
 
+#if defined(OS_ANDROID)
+const char TranslatePrefs::kPrefTranslateAutoAlwaysCount[] =
+    "translate_auto_always_count";
+const char TranslatePrefs::kPrefTranslateAutoNeverCount[] =
+    "translate_auto_never_count";
+#endif
+
 // For reading ULP prefs.
 const char kConfidence[] = "confidence";
 const char kLanguage[] = "language";
 const char kPreference[] = "preference";
 const char kProbability[] = "probability";
 const char kReading[] = "reading";
 
 // The below properties used to be used but now are deprecated. Don't use them
 // since an old profile might have some values there.
 //
@@ skipping 124 matching lines @@
 
   std::vector<std::string> languages;
   GetLanguageList(&languages);
   for (std::vector<std::string>::const_iterator it = languages.begin();
        it != languages.end(); ++it) {
     const std::string& language = *it;
     ResetTranslationAcceptedCount(language);
     ResetTranslationDeniedCount(language);
     ResetTranslationIgnoredCount(language);
   }
+#if defined(OS_ANDROID)
+  prefs_->ClearPref(kPrefTranslateAutoAlwaysCount);
+  prefs_->ClearPref(kPrefTranslateAutoNeverCount);
+#endif
 
   prefs_->ClearPref(kPrefTranslateLastDeniedTimeForLanguage);
   prefs_->ClearPref(kPrefTranslateTooOftenDeniedForLanguage);
 }
 
 bool TranslatePrefs::IsBlockedLanguage(
     const std::string& original_language) const {
   return IsValueBlacklisted(kPrefTranslateBlockedLanguages, original_language);
 }
 
@@ skipping 153 matching lines @@
   dict->GetInteger(language, &count);
   dict->SetInteger(language, count + 1);
 }
 
 void TranslatePrefs::ResetTranslationAcceptedCount(
     const std::string& language) {
   DictionaryPrefUpdate update(prefs_, kPrefTranslateAcceptedCount);
   update.Get()->SetInteger(language, 0);
 }
 
+#if defined(OS_ANDROID)
+int TranslatePrefs::GetTranslationAutoAlwaysCount(
+    const std::string& language) const {
+  const base::DictionaryValue* dict =
+      prefs_->GetDictionary(kPrefTranslateAutoAlwaysCount);
+  int count = 0;
+  return dict->GetInteger(language, &count) ? count : 0;
+}
+
+void TranslatePrefs::IncrementTranslationAutoAlwaysCount(
+    const std::string& language) {
+  DictionaryPrefUpdate update(prefs_, kPrefTranslateAutoAlwaysCount);
+  base::DictionaryValue* dict = update.Get();
+  int count = 0;
+  dict->GetInteger(language, &count);
+  dict->SetInteger(language, count + 1);
+}
+
+void TranslatePrefs::ResetTranslationAutoAlwaysCount(
+    const std::string& language) {
+  DictionaryPrefUpdate update(prefs_, kPrefTranslateAutoAlwaysCount);
+  update.Get()->SetInteger(language, 0);
+}
+
+int TranslatePrefs::GetTranslationAutoNeverCount(
+    const std::string& language) const {
+  const base::DictionaryValue* dict =
+      prefs_->GetDictionary(kPrefTranslateAutoNeverCount);
+  int count = 0;
+  return dict->GetInteger(language, &count) ? count : 0;
+}
+
+void TranslatePrefs::IncrementTranslationAutoNeverCount(
+    const std::string& language) {
+  DictionaryPrefUpdate update(prefs_, kPrefTranslateAutoNeverCount);
+  base::DictionaryValue* dict = update.Get();
+  int count = 0;
+  dict->GetInteger(language, &count);
+  dict->SetInteger(language, count + 1);
+}
+
+void TranslatePrefs::ResetTranslationAutoNeverCount(
+    const std::string& language) {
+  DictionaryPrefUpdate update(prefs_, kPrefTranslateAutoNeverCount);
+  update.Get()->SetInteger(language, 0);
+}
+#endif  // defined(OS_ANDROID)
+
 void TranslatePrefs::UpdateLastDeniedTime(const std::string& language) {
   if (IsTooOftenDenied(language))
     return;
 
   DenialTimeUpdate update(prefs_, language, 2);
   base::Time now = base::Time::Now();
   base::Time oldest_denial_time = update.GetOldestDenialTime();
   update.AddDenialTime(now);
 
   if (oldest_denial_time.is_null())
@@ skipping 114 matching lines @@
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterListPref(kPrefTranslateBlockedLanguages,
                              user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterDictionaryPref(kPrefTranslateLastDeniedTimeForLanguage);
   registry->RegisterDictionaryPref(
       kPrefTranslateTooOftenDeniedForLanguage,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterDictionaryPref(
       kPrefLanguageProfile,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF);
+#if defined(OS_ANDROID)
+  registry->RegisterDictionaryPref(
+      kPrefTranslateAutoAlwaysCount,
+      user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
+  registry->RegisterDictionaryPref(
+      kPrefTranslateAutoNeverCount,
+      user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
+#endif
 }
 
 // static
 void TranslatePrefs::MigrateUserPrefs(PrefService* user_prefs,
                                       const char* accept_languages_pref) {
   // Old format of kPrefTranslateWhitelists
   // - original language -> list of target langs to auto-translate
   // - list of langs is in order of being enabled i.e. last in list is the
   //   most recent language that user enabled via
   //   Always translate |source_lang| to |target_lang|"
@@ skipping 129 matching lines @@
     out_value->push_back(it);
   std::sort(out_value->begin(), out_value->end(),
             [](const LanguageAndProbability& left,
                const LanguageAndProbability& right) {
               return left.second > right.second;
             });
   return confidence;
 }
 
 }  // namespace translate