Translate: Hide the bubble if the user denies translating 2 times within 24 hours

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/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/translate/core/browser/translate_accept_languages.h"
 #include "components/translate/core/browser/translate_download_manager.h"
 #include "components/translate/core/common/translate_util.h"
 
 const char TranslatePrefs::kPrefTranslateLanguageBlacklist[] =
     "translate_language_blacklist";
 const char TranslatePrefs::kPrefTranslateSiteBlacklist[] =
     "translate_site_blacklist";
 const char TranslatePrefs::kPrefTranslateWhitelists[] =
     "translate_whitelists";
 const char TranslatePrefs::kPrefTranslateDeniedCount[] =
     "translate_denied_count";
 const char TranslatePrefs::kPrefTranslateAcceptedCount[] =
     "translate_accepted_count";
 const char TranslatePrefs::kPrefTranslateBlockedLanguages[] =
     "translate_blocked_languages";
+const char TranslatePrefs::kPrefTranslateLastDeniedTime[] =
+    "translate_last_denied_time";
+const char TranslatePrefs::kPrefTranslateTooOftenDenied[] =
+    "translate_too_often_denied";
 
 namespace {
 
 void GetBlacklistedLanguages(const PrefService* prefs,
                              std::vector<std::string>* languages) {
   DCHECK(languages);
   DCHECK(languages->empty());
 
   const char* key = TranslatePrefs::kPrefTranslateLanguageBlacklist;
   const base::ListValue* list = prefs->GetList(key);
@@ skipping 56 matching lines @@
   ClearWhitelistedLanguagePairs();
 
   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);
   }
+
+  prefs_->ClearPref(kPrefTranslateLastDeniedTime);
+  prefs_->ClearPref(kPrefTranslateTooOftenDenied);
 }
 
 bool TranslatePrefs::IsBlockedLanguage(
     const std::string& original_language) const {
   return IsValueBlacklisted(kPrefTranslateBlockedLanguages,
                             original_language);
 }
 
 void TranslatePrefs::BlockLanguage(const std::string& original_language) {
   BlacklistValue(kPrefTranslateBlockedLanguages, original_language);
@@ skipping 132 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);
 }
 
+void TranslatePrefs::UpdateLastDeniedTime() {
+  if (IsTooOftenDenied())
+    return;
+
+  double time = prefs_->GetDouble(kPrefTranslateLastDeniedTime);
+  base::Time last_closed_time = base::Time::FromJsTime(time);
+  base::Time now = base::Time::Now();
+  prefs_->SetDouble(kPrefTranslateLastDeniedTime, now.ToJsTime());
+  if (now - last_closed_time <= base::TimeDelta::FromDays(1))
+    prefs_->SetBoolean(kPrefTranslateTooOftenDenied, true);
+}
+
+bool TranslatePrefs::IsTooOftenDenied() const {
+  return prefs_->GetBoolean(kPrefTranslateTooOftenDenied);
+}
+
 void TranslatePrefs::GetLanguageList(std::vector<std::string>* languages) {
   DCHECK(languages);
   DCHECK(languages->empty());
 
 #if defined(OS_CHROMEOS)
   const char* key = preferred_languages_pref_.c_str();
 #else
   const char* key = accept_languages_pref_.c_str();
 #endif
 
@@ skipping 60 matching lines @@
       kPrefTranslateWhitelists,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterDictionaryPref(
       kPrefTranslateDeniedCount,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterDictionaryPref(
       kPrefTranslateAcceptedCount,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterListPref(kPrefTranslateBlockedLanguages,
                              user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
+  registry->RegisterDoublePref(
+      kPrefTranslateLastDeniedTime, 0,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(
+      kPrefTranslateTooOftenDenied, false,
+      user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 }
 
 // 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 183 matching lines @@
 
 bool TranslatePrefs::IsListEmpty(const char* pref_id) const {
   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());
 }