Extend the translate prefs interface with new methods to clear/check blacklisted sites/languages

chrome/browser/translate/translate_prefs.cc

 // Copyright (c) 2011 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 "chrome/browser/translate/translate_prefs.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/string_util.h"
 #include "chrome/browser/prefs/pref_registry_syncable.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.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";
 
 // TranslatePrefs: public: -----------------------------------------------------
 
 TranslatePrefs::TranslatePrefs(PrefService* user_prefs)
     : prefs_(user_prefs) {
 }
 
 bool TranslatePrefs::IsLanguageBlacklisted(
-    const std::string& original_language) {
+    const std::string& original_language) const {
   return IsValueBlacklisted(kPrefTranslateLanguageBlacklist, original_language);
 }
 
 void TranslatePrefs::BlacklistLanguage(const std::string& original_language) {
   BlacklistValue(kPrefTranslateLanguageBlacklist, original_language);
 }
 
 void TranslatePrefs::RemoveLanguageFromBlacklist(
     const std::string& original_language) {
   RemoveValueFromBlacklist(kPrefTranslateLanguageBlacklist, original_language);
 }
 
-bool TranslatePrefs::IsSiteBlacklisted(const std::string& site) {
+bool TranslatePrefs::IsSiteBlacklisted(const std::string& site) const {
   return IsValueBlacklisted(kPrefTranslateSiteBlacklist, site);
 }
 
 void TranslatePrefs::BlacklistSite(const std::string& site) {
   BlacklistValue(kPrefTranslateSiteBlacklist, site);
 }
 
 void TranslatePrefs::RemoveSiteFromBlacklist(const std::string& site) {
   RemoveValueFromBlacklist(kPrefTranslateSiteBlacklist, site);
 }
@@ skipping 28 matching lines @@
     const std::string& target_language) {
   DictionaryPrefUpdate update(prefs_, kPrefTranslateWhitelists);
   DictionaryValue* dict = update.Get();
   if (!dict) {
     NOTREACHED() << "Unregistered translate whitelist pref";
     return;
   }
   dict->Remove(original_language, NULL);
 }
 
-int TranslatePrefs::GetTranslationDeniedCount(const std::string& language) {
+bool TranslatePrefs::HasBlacklistedLanguages() const {
+  return !IsListEmpty(kPrefTranslateLanguageBlacklist);
+}
+
+void TranslatePrefs::ClearBlacklistedLanguages() {
+  prefs_->ClearPref(kPrefTranslateLanguageBlacklist);
+}
+
+bool TranslatePrefs::HasBlacklistedSites() {
+  return !IsListEmpty(kPrefTranslateSiteBlacklist);
+}
+
+void TranslatePrefs::ClearBlacklistedSites() {
+  prefs_->ClearPref(kPrefTranslateSiteBlacklist);
+}
+
+int TranslatePrefs::GetTranslationDeniedCount(
+    const std::string& language) const {
   const DictionaryValue* dict =
       prefs_->GetDictionary(kPrefTranslateDeniedCount);
   int count = 0;
   return dict->GetInteger(language, &count) ? count : 0;
 }
 
 void TranslatePrefs::IncrementTranslationDeniedCount(
     const std::string& language) {
   DictionaryPrefUpdate update(prefs_, kPrefTranslateDeniedCount);
   DictionaryValue* dict = update.Get();
@@ skipping 100 matching lines @@
         target_lang.empty())
       dict->Remove(*iter, NULL);
      else
       dict->SetString(*iter, target_lang);
   }
 }
 
 // TranslatePrefs: private: ----------------------------------------------------
 
 bool TranslatePrefs::IsValueInList(const ListValue* list,
-    const std::string& in_value) {
+    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;
 }
 
 bool TranslatePrefs::IsValueBlacklisted(const char* pref_id,
-    const std::string& value) {
+    const std::string& value) const {
   const ListValue* blacklist = prefs_->GetList(pref_id);
   return (blacklist && !blacklist->empty() && IsValueInList(blacklist, value));
 }
 
 void TranslatePrefs::BlacklistValue(const char* pref_id,
     const std::string& value) {
   {
     ListPrefUpdate update(prefs_, pref_id);
     ListValue* blacklist = update.Get();
     if (!blacklist) {
@@ skipping 10 matching lines @@
   ListValue* blacklist = update.Get();
   if (!blacklist) {
     NOTREACHED() << "Unregistered translate blacklist pref";
     return;
   }
   StringValue string_value(value);
   blacklist->Remove(string_value, NULL);
 }
 
 bool TranslatePrefs::IsLanguageWhitelisted(
-    const std::string& original_language, std::string* target_language) {
+    const std::string& original_language, std::string* target_language) const {
   const DictionaryValue* dict = prefs_->GetDictionary(kPrefTranslateWhitelists);
   if (dict && dict->GetString(original_language, target_language)) {
     DCHECK(!target_language->empty());
     return !target_language->empty();
   }
   return false;
 }
+
+bool TranslatePrefs::IsListEmpty(const char* pref_id) const {
+  const ListValue* blacklist = prefs_->GetList(pref_id);
+  return (blacklist == NULL || blacklist->empty());
+}