Replace SetContentSetting method of the content_settings::Provider interface with GetWebsiteSetting

chrome/browser/content_settings/content_settings_pref_provider.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/content_settings/content_settings_pref_provider.h"
 
 #include <map>
 #include <string>
 #include <utility>
 
@@ skipping 133 matching lines @@
   }
 
   pref_change_registrar_.Init(prefs_);
   pref_change_registrar_.Add(prefs::kContentSettingsPatterns, this);
   pref_change_registrar_.Add(prefs::kContentSettingsPatternPairs, this);
   pref_change_registrar_.Add(prefs::kGeolocationContentSettings, this);
   pref_change_registrar_.Add(prefs::kDesktopNotificationAllowedOrigins, this);
   pref_change_registrar_.Add(prefs::kDesktopNotificationDeniedOrigins, this);
 }
 
-void PrefProvider::SetContentSetting(
+void PrefProvider::SetWebsiteSetting(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
     const ResourceIdentifier& resource_identifier,
-    ContentSetting setting) {
+    const Value* value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(prefs_);
 
   // Update in memory value map.
   OriginIdentifierValueMap* map_to_modify = &incognito_value_map_;
   if (!is_incognito_)
     map_to_modify = &value_map_;
 
   {
     base::AutoLock auto_lock(lock_);
-    if (setting == CONTENT_SETTING_DEFAULT) {
+    if (value == NULL) {
       map_to_modify->DeleteValue(
           primary_pattern,
           secondary_pattern,
           content_type,
           resource_identifier);
     } else {
       map_to_modify->SetValue(
           primary_pattern,
           secondary_pattern,
           content_type,
           resource_identifier,
-          Value::CreateIntegerValue(setting));
+          value->DeepCopy());
     }
   }
   // Update the content settings preference.
   if (!is_incognito_) {
     UpdatePref(primary_pattern,
                secondary_pattern,
                content_type,
                resource_identifier,
-               setting);
+               value);
     prefs_->ScheduleSavePersistentPrefs();
   }
 
   NotifyObservers(
       primary_pattern, secondary_pattern, content_type, resource_identifier);
 }
 
 void PrefProvider::ClearAllContentSettingsRules(
     ContentSettingsType content_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 16 matching lines @@
     prefs_->ScheduleSavePersistentPrefs();
   }
 
   for (std::vector<Rule>::const_iterator it = rules_to_delete.begin();
        it != rules_to_delete.end(); ++it) {
     UpdatePref(
         it->primary_pattern,
         it->secondary_pattern,
         content_type,
         "",
-        CONTENT_SETTING_DEFAULT);
+        NULL);
   }
   NotifyObservers(ContentSettingsPattern(),
                   ContentSettingsPattern(),
                   content_type,
                   std::string());
 }
 
 void PrefProvider::Observe(
     int type,
     const content::NotificationSource& source,
@@ skipping 51 matching lines @@
 }
 
 // ////////////////////////////////////////////////////////////////////////////
 // Private
 
 void PrefProvider::UpdatePref(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
     const ResourceIdentifier& resource_identifier,
-    ContentSetting setting) {
+    const base::Value* value) {
   // Ensure that |lock_| is not held by this thread, since this function will
   // send out notifications (by |~DictionaryPrefUpdate|).
   AssertLockNotHeld();
 
   AutoReset<bool> auto_reset(&updating_preferences_, true);
   {
     DictionaryPrefUpdate update(prefs_,
                                 prefs::kContentSettingsPatternPairs);
     DictionaryValue* pattern_pairs_settings = update.Get();
     UpdatePatternPairsSettings(primary_pattern,
                                secondary_pattern,
                                content_type,
                                resource_identifier,
-                               setting,
+                               value,
                                pattern_pairs_settings);
   }
   if (content_type != CONTENT_SETTINGS_TYPE_GEOLOCATION &&
       content_type != CONTENT_SETTINGS_TYPE_NOTIFICATIONS) {
     UpdateObsoletePatternsPref(primary_pattern,
                                secondary_pattern,
                                content_type,
                                resource_identifier,
-                               setting);
+                               ValueToContentSetting(value));
   } else if (content_type == CONTENT_SETTINGS_TYPE_GEOLOCATION) {
-    UpdateObsoleteGeolocationPref(primary_pattern, secondary_pattern, setting);
+    UpdateObsoleteGeolocationPref(
+        primary_pattern,
+        secondary_pattern,
+        ValueToContentSetting(value));
   } else if (content_type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS) {
     ListPrefUpdate update_allowed_sites(
         prefs_, prefs::kDesktopNotificationAllowedOrigins);
     ListPrefUpdate update_denied_sites(
         prefs_, prefs::kDesktopNotificationDeniedOrigins);
     UpdateObsoleteNotificationsSettings(primary_pattern,
                                         secondary_pattern,
-                                        setting,
+                                        ValueToContentSetting(value),
                                         update_allowed_sites.Get(),
                                         update_denied_sites.Get());
   }
 }
 
 void PrefProvider::ReadContentSettingsFromPref(bool overwrite) {
   // |DictionaryPrefUpdate| sends out notifications when destructed. This
   // construction order ensures |AutoLock| gets destroyed first and |lock_| is
   // not held when the notifications are sent. Also, |auto_reset| must be still
   // valid when the notifications are sent, so that |Observe| skips the
@@ skipping 156 matching lines @@
       }
     }
   }
 }
 
 void PrefProvider::UpdatePatternPairsSettings(
       const ContentSettingsPattern& primary_pattern,
       const ContentSettingsPattern& secondary_pattern,
       ContentSettingsType content_type,
       const ResourceIdentifier& resource_identifier,
-      ContentSetting setting,
+      const base::Value* value,
       DictionaryValue* pattern_pairs_settings) {
   // Get settings dictionary for the given patterns.
   std::string pattern_str(CreatePatternString(primary_pattern,
                                               secondary_pattern));
   DictionaryValue* settings_dictionary = NULL;
   bool found = pattern_pairs_settings->GetDictionaryWithoutPathExpansion(
       pattern_str, &settings_dictionary);
 
-  if (!found && (setting != CONTENT_SETTING_DEFAULT)) {
+  if (!found && (value != NULL)) {

[Bernhard Bauer, 2011/11/11 14:00:40]

Nit: the |!= NULL| is unnecessary.

[markusheintz_, 2011/11/14 11:15:10]

Done.

     settings_dictionary = new DictionaryValue;
     pattern_pairs_settings->SetWithoutPathExpansion(
         pattern_str, settings_dictionary);
   }
 
   if (settings_dictionary) {
     std::string res_dictionary_path;
     if (GetResourceTypeName(content_type, &res_dictionary_path)) {
       DictionaryValue* resource_dictionary = NULL;
       found = settings_dictionary->GetDictionary(
           res_dictionary_path, &resource_dictionary);
       if (!found) {
-        if (setting == CONTENT_SETTING_DEFAULT)
+        if (value == NULL)
           return;  // Nothing to remove. Exit early.
         resource_dictionary = new DictionaryValue;
         settings_dictionary->Set(res_dictionary_path, resource_dictionary);
       }
       // Update resource dictionary.
-      if (setting == CONTENT_SETTING_DEFAULT) {
+      if (value == NULL) {
         resource_dictionary->RemoveWithoutPathExpansion(resource_identifier,
                                                         NULL);
         if (resource_dictionary->empty()) {
           settings_dictionary->RemoveWithoutPathExpansion(
               res_dictionary_path, NULL);
         }
       } else {
         resource_dictionary->SetWithoutPathExpansion(
-            resource_identifier, Value::CreateIntegerValue(setting));
+            resource_identifier, value->DeepCopy());
       }
     } else {
       // Update settings dictionary.
       std::string setting_path = GetTypeName(content_type);
-      if (setting == CONTENT_SETTING_DEFAULT) {
+      if (value == NULL) {
         settings_dictionary->RemoveWithoutPathExpansion(setting_path,
                                                         NULL);
       } else {
         settings_dictionary->SetWithoutPathExpansion(
-            setting_path, Value::CreateIntegerValue(setting));
+            setting_path, value->DeepCopy());
       }
     }
     // Remove the settings dictionary if it is empty.
     if (settings_dictionary->empty()) {
       pattern_pairs_settings->RemoveWithoutPathExpansion(
           pattern_str, NULL);
     }
   }
 }
 
@@ skipping 147 matching lines @@
         ContentSettingsType content_type = static_cast<ContentSettingsType>(i);
 
         int setting_int_value = CONTENT_SETTING_DEFAULT;
         if (host_settings_dictionary->GetIntegerWithoutPathExpansion(
                 GetTypeName(content_type), &setting_int_value)) {
           ContentSetting setting = IntToContentSetting(setting_int_value);
 
           setting = FixObsoleteCookiePromptMode(content_type, setting);
           setting = ClickToPlayFixup(content_type, setting);
 
-          // TODO(markusheintz): Maybe this check can be removed.
+          scoped_ptr<base::Value> value(Value::CreateIntegerValue(setting));
           if (setting != CONTENT_SETTING_DEFAULT) {
-            SetContentSetting(
+            SetWebsiteSetting(
                 pattern,
                 pattern,
                 content_type,
                 "",
-                setting);
+                value.get());
           }
         }
       }
     }
     prefs_->ClearPref(prefs::kPerHostContentSettings);
   }
 }
 
 void PrefProvider::MigrateObsoletePopupsPref() {
   if (prefs_->HasPrefPath(prefs::kPopupWhitelistedHosts)) {
     const ListValue* whitelist_pref =
         prefs_->GetList(prefs::kPopupWhitelistedHosts);
     for (ListValue::const_iterator i(whitelist_pref->begin());
          i != whitelist_pref->end(); ++i) {
       std::string host;
       (*i)->GetAsString(&host);
-      SetContentSetting(ContentSettingsPattern::FromString(host),
+      scoped_ptr<base::Value> value(Value::CreateIntegerValue(
+          CONTENT_SETTING_ALLOW));
+      SetWebsiteSetting(ContentSettingsPattern::FromString(host),
                         ContentSettingsPattern::FromString(host),
                         CONTENT_SETTINGS_TYPE_POPUPS,
                         "",
-                        CONTENT_SETTING_ALLOW);
+                        value.get());
     }
     prefs_->ClearPref(prefs::kPopupWhitelistedHosts);
   }
 }
 
 void PrefProvider::MigrateObsoleteContentSettingsPatternPref() {
   // Ensure that |lock_| is not held by this thread, since this function will
   // send out notifications (by |~DictionaryPrefUpdate|).
   AssertLockNotHeld();
 
@@ skipping 160 matching lines @@
     DCHECK(found);
 
     for (DictionaryValue::key_iterator j =
              requesting_origin_settings->begin_keys();
          j != requesting_origin_settings->end_keys();
          ++j) {
       const std::string& secondary_key(*j);
       GURL secondary_url(secondary_key);
       DCHECK(secondary_url.is_valid());
 
-      int setting_value;
-      found = requesting_origin_settings->GetIntegerWithoutPathExpansion(
-          secondary_key, &setting_value);
+      base::Value* value = NULL;
+      found = requesting_origin_settings->GetWithoutPathExpansion(
+          secondary_key, &value);
       DCHECK(found);
 
       ContentSettingsPattern primary_pattern =
           ContentSettingsPattern::FromURLNoWildcard(primary_url);
       ContentSettingsPattern secondary_pattern =
           ContentSettingsPattern::FromURLNoWildcard(secondary_url);
       DCHECK(primary_pattern.IsValid() && secondary_pattern.IsValid());
 
       UpdatePatternPairsSettings(primary_pattern,
                                  secondary_pattern,
                                  CONTENT_SETTINGS_TYPE_GEOLOCATION,
                                  std::string(),
-                                 IntToContentSetting(setting_value),
+                                 value,
                                  pattern_pairs_settings);
     }
   }
 }
 
 void PrefProvider::MigrateObsoleteNotificationsPrefs() {
   // Ensure that |lock_| is not held by this thread, since this function will
   // send out notifications (by |~DictionaryPrefUpdate|).
   AssertLockNotHeld();
 
   // The notifications settings in the preferences
   // prefs::kContentSettingsPatternPairs do not contain the latest
   // notifications settings. So all notification settings are cleared and
   // migrated from the obsolete preferences for notifications settings that
   // contain the latest settings.
   DictionaryPrefUpdate update(prefs_, prefs::kContentSettingsPatternPairs);
   DictionaryValue* pattern_pairs_settings = update.Get();
   ClearSettings(CONTENT_SETTINGS_TYPE_NOTIFICATIONS, pattern_pairs_settings);
 
   const ListValue* allowed_origins =
       prefs_->GetList(prefs::kDesktopNotificationAllowedOrigins);
   for (size_t i = 0; i < allowed_origins->GetSize(); ++i) {
     std::string url_string;
     bool status = allowed_origins->GetString(i, &url_string);
     DCHECK(status);
     ContentSettingsPattern primary_pattern =
         ContentSettingsPattern::FromURLNoWildcard(GURL(url_string));
     DCHECK(primary_pattern.IsValid());
+    scoped_ptr<base::Value> value(
+        Value::CreateIntegerValue(CONTENT_SETTING_ALLOW));
     UpdatePatternPairsSettings(primary_pattern,
                                ContentSettingsPattern::Wildcard(),
                                CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
                                std::string(),
-                               CONTENT_SETTING_ALLOW,
+                               value.get(),
                                pattern_pairs_settings);
   }
 
   const ListValue* denied_origins =
       prefs_->GetList(prefs::kDesktopNotificationDeniedOrigins);
   for (size_t i = 0; i < denied_origins->GetSize(); ++i) {
     std::string url_string;
     bool status = denied_origins->GetString(i, &url_string);
     DCHECK(status);
     ContentSettingsPattern primary_pattern =
         ContentSettingsPattern::FromURLNoWildcard(GURL(url_string));
     DCHECK(primary_pattern.IsValid());
+    scoped_ptr<base::Value> value(
+        Value::CreateIntegerValue(CONTENT_SETTING_BLOCK));
     UpdatePatternPairsSettings(primary_pattern,
                                ContentSettingsPattern::Wildcard(),
                                CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
                                std::string(),
-                               CONTENT_SETTING_BLOCK,
+                               value.get(),
                                pattern_pairs_settings);
   }
 }
 
 void PrefProvider::SyncObsoletePrefs() {
   // Ensure that |lock_| is not held by this thread, since this function will
   // send out notifications (by |~DictionaryPrefUpdate|).
   AssertLockNotHeld();
 
   DCHECK(prefs_);
@@ skipping 49 matching lines @@
 
 void PrefProvider::AssertLockNotHeld() const {
 #if !defined(NDEBUG)
   // |Lock::Acquire()| will assert if the lock is held by this thread.
   lock_.Acquire();
   lock_.Release();
 #endif
 }
 
 }  // namespace content_settings