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

chrome/browser/content_settings/content_settings_default_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_default_provider.h"
 
 #include <string>
 #include <vector>
 
 #include "base/auto_reset.h"
@@ skipping 52 matching lines @@
   Rule Next() {
     DCHECK(setting_ != CONTENT_SETTING_DEFAULT);
     ContentSetting setting_to_return = setting_;
     setting_ = CONTENT_SETTING_DEFAULT;
     return Rule(ContentSettingsPattern::Wildcard(),
                 ContentSettingsPattern::Wildcard(),
                 Value::CreateIntegerValue(setting_to_return));
   }
 
  private:
+  // TODO(markusheintz): |ContentSetting| should be replaced with a |Value|.
   ContentSetting setting_;
 };
 
 }  // namespace
 
 // static
 void DefaultProvider::RegisterUserPrefs(PrefService* prefs) {
   // The registration of the preference prefs::kDefaultContentSettings should
   // also include the default values for default content settings. This allows
   // functional tests to get default content settings by reading the preference
@@ skipping 19 matching lines @@
 DefaultProvider::DefaultProvider(PrefService* prefs, bool incognito)
     : prefs_(prefs),
       is_incognito_(incognito),
       updating_preferences_(false) {
   DCHECK(prefs_);
   MigrateObsoleteNotificationPref();
   MigrateObsoleteGeolocationPref();
 
   // Read global defaults.
   ReadDefaultSettings(true);
-  if (default_content_settings_.settings[CONTENT_SETTINGS_TYPE_COOKIES] ==
-      CONTENT_SETTING_BLOCK) {
+
+  ContentSetting cookie_setting = ValueToContentSetting(
+      default_settings_[CONTENT_SETTINGS_TYPE_COOKIES].get());
+  if (cookie_setting == CONTENT_SETTING_BLOCK) {
     UserMetrics::RecordAction(
         UserMetricsAction("CookieBlockingEnabledPerDefault"));
   } else {
     UserMetrics::RecordAction(
         UserMetricsAction("CookieBlockingDisabledPerDefault"));
   }
 
   pref_change_registrar_.Init(prefs_);
   pref_change_registrar_.Add(prefs::kDefaultContentSettings, this);
   pref_change_registrar_.Add(prefs::kGeolocationDefaultContentSetting, this);
 }
 
 DefaultProvider::~DefaultProvider() {
 }
 
-void DefaultProvider::SetContentSetting(
+bool DefaultProvider::SetWebsiteSetting(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
     const ResourceIdentifier& resource_identifier,
-    ContentSetting setting) {
+    Value* value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(prefs_);
 
   // Ignore non default settings
   if (primary_pattern != ContentSettingsPattern::Wildcard() ||
       secondary_pattern != ContentSettingsPattern::Wildcard()) {
-    return;
+    return false;
   }
 
   // The default settings may not be directly modified for OTR sessions.
   // Instead, they are synced to the main profile's setting.
   if (is_incognito_)
-    return;
+    return false;
 
   std::string dictionary_path = GetTypeName(content_type);
   {
     AutoReset<bool> auto_reset(&updating_preferences_, true);
     DictionaryPrefUpdate update(prefs_, prefs::kDefaultContentSettings);
     DictionaryValue* default_settings_dictionary = update.Get();
 
     // |DefaultProvider| should not send any notifications when holding
     // |lock_|. |DictionaryPrefUpdate| destructor and
     // |PrefService::SetInteger()| send out notifications. As a response, the
     // upper layers may call |GetAllContentSettingRules| which acquires |lock_|
     // again.
+    // TODO(markusheintz): Hardcoded default settings should be handled by the
+    // HostContentSettingsMap itself. The DefaultProvider should only deal with
+    // user set default values and should return NULL if no user defined
+    // settings are avaliable.
     {
       base::AutoLock lock(lock_);
-      if (setting == CONTENT_SETTING_DEFAULT ||
-          setting == kDefaultSettings[content_type]) {
-        default_content_settings_.settings[content_type] =
-            kDefaultSettings[content_type];
+      if (value == NULL ||
+          ValueToContentSetting(value) == kDefaultSettings[content_type]) {
+        // If |value| is NULL we need to reset the default setting the the
+        // hardcoded default.
+        default_settings_[content_type].reset(
+            Value::CreateIntegerValue(kDefaultSettings[content_type]));
+
+        // If |value| is null or equal to the hardcoded default setting then
+        // remove the corresponding pref entry as it is not needed.
         default_settings_dictionary->RemoveWithoutPathExpansion(dictionary_path,
                                                                 NULL);
       } else {
-        default_content_settings_.settings[content_type] = setting;
+        default_settings_[content_type].reset(value->DeepCopy());
         default_settings_dictionary->SetWithoutPathExpansion(
-            dictionary_path, Value::CreateIntegerValue(setting));
+            dictionary_path, value);
       }
     }
 
     // Keep the obsolete pref in sync as long as backwards compatibility is
     // required. This is required to keep sync working correctly.
     if (content_type == CONTENT_SETTINGS_TYPE_GEOLOCATION) {
-       prefs_->SetInteger(prefs::kGeolocationDefaultContentSetting,
-                          setting == CONTENT_SETTING_DEFAULT ?
-                              kDefaultSettings[content_type] : setting);
+      if (value) {
+        prefs_->Set(prefs::kGeolocationDefaultContentSetting, *value);

[Bernhard Bauer, 2011/11/15 15:40:28]

I'm not happy that we pass ownership of |value| to |default_settings_dictionary|
but still keep using it. That can lead to subtle bugs if we change something and
|value| suddenly gets invalidated from under us.

[markusheintz_, 2011/11/15 17:36:58]

Done.

+      } else {
+        prefs_->ClearPref(prefs::kGeolocationDefaultContentSetting);
+      }
     }
   }
 
   NotifyObservers(ContentSettingsPattern(),
                   ContentSettingsPattern(),
                   content_type,
                   std::string());
+
+  return true;
 }
 
 RuleIterator* DefaultProvider::GetRuleIterator(
     ContentSettingsType content_type,
     const ResourceIdentifier& resource_identifier,
     bool incognito) const {
   base::AutoLock lock(lock_);
   if (resource_identifier.empty()) {
-    return new DefaultRuleIterator(
-        default_content_settings_.settings[content_type]);
+    int int_value = 0;
+    ValueMap::const_iterator it(default_settings_.find(content_type));
+    if (it != default_settings_.end()) {
+      it->second->GetAsInteger(&int_value);
+    } else {
+      NOTREACHED();
+    }
+    return new DefaultRuleIterator(ContentSetting(int_value));
   } else {
     return new EmptyRuleIterator();
   }
 }
 
 void DefaultProvider::ClearAllContentSettingsRules(
     ContentSettingsType content_type) {
   // TODO(markusheintz): This method is only called when the
   // |DesktopNotificationService| calls |ClearAllSettingsForType| method on the
   // |HostContentSettingsMap|. Don't implement this method yet, otherwise the
@@ skipping 40 matching lines @@
     NOTREACHED() << "Unexpected notification";
   }
 }
 
 void DefaultProvider::ReadDefaultSettings(bool overwrite) {
   base::AutoLock lock(lock_);
   const DictionaryValue* default_settings_dictionary =
       prefs_->GetDictionary(prefs::kDefaultContentSettings);
 
   if (overwrite)
-    default_content_settings_ = ContentSettings();
+    default_settings_.clear();
 
   // Careful: The returned value could be NULL if the pref has never been set.
-  if (default_settings_dictionary) {
-    GetSettingsFromDictionary(default_settings_dictionary,
-                              &default_content_settings_);
-  }
+  if (default_settings_dictionary)
+    GetSettingsFromDictionary(default_settings_dictionary);
+
   ForceDefaultsToBeExplicit();
 }
 
 void DefaultProvider::ForceDefaultsToBeExplicit() {
   for (int i = 0; i < CONTENT_SETTINGS_NUM_TYPES; ++i) {
-    if (default_content_settings_.settings[i] == CONTENT_SETTING_DEFAULT)
-      default_content_settings_.settings[i] = kDefaultSettings[i];
+    ContentSettingsType type = ContentSettingsType(i);
+    if (!default_settings_[type].get())
+      default_settings_[type].reset(
+          Value::CreateIntegerValue(kDefaultSettings[i]));
   }
 }
 
 void DefaultProvider::GetSettingsFromDictionary(
-    const DictionaryValue* dictionary,
-    ContentSettings* settings) {
+    const DictionaryValue* dictionary) {
   for (DictionaryValue::key_iterator i(dictionary->begin_keys());
        i != dictionary->end_keys(); ++i) {
     const std::string& content_type(*i);
     for (size_t type = 0; type < CONTENT_SETTINGS_NUM_TYPES; ++type) {
       if (content_type == GetTypeName(ContentSettingsType(type))) {
-        int setting = CONTENT_SETTING_DEFAULT;
+        int int_value = CONTENT_SETTING_DEFAULT;
         bool found = dictionary->GetIntegerWithoutPathExpansion(content_type,
-                                                                &setting);
+                                                                &int_value);
         DCHECK(found);
-        settings->settings[type] = IntToContentSetting(setting);
+        default_settings_[ContentSettingsType(type)].reset(
+            Value::CreateIntegerValue(int_value));
         break;
       }
     }
   }
-  // Migrate obsolete cookie prompt mode/
-  if (settings->settings[CONTENT_SETTINGS_TYPE_COOKIES] ==
-      CONTENT_SETTING_ASK)
-    settings->settings[CONTENT_SETTINGS_TYPE_COOKIES] = CONTENT_SETTING_BLOCK;
+  // Migrate obsolete cookie prompt mode.
+  if (ValueToContentSetting(
+          default_settings_[CONTENT_SETTINGS_TYPE_COOKIES].get()) ==
+              CONTENT_SETTING_ASK) {
+    default_settings_[CONTENT_SETTINGS_TYPE_COOKIES].reset(
+        Value::CreateIntegerValue(CONTENT_SETTING_BLOCK));
+  }
 
-  settings->settings[CONTENT_SETTINGS_TYPE_PLUGINS] =
-      ClickToPlayFixup(CONTENT_SETTINGS_TYPE_PLUGINS,
-                       settings->settings[CONTENT_SETTINGS_TYPE_PLUGINS]);
+  if (default_settings_[CONTENT_SETTINGS_TYPE_PLUGINS].get()) {
+    ContentSetting plugin_setting = ValueToContentSetting(
+        default_settings_[CONTENT_SETTINGS_TYPE_PLUGINS].get());
+    plugin_setting =
+        ClickToPlayFixup(CONTENT_SETTINGS_TYPE_PLUGINS, plugin_setting);
+    default_settings_[CONTENT_SETTINGS_TYPE_PLUGINS].reset(
+        Value::CreateIntegerValue(plugin_setting));
+  }
 }
 
 void DefaultProvider::MigrateObsoleteNotificationPref() {
   if (prefs_->HasPrefPath(prefs::kDesktopNotificationDefaultContentSetting)) {
-    ContentSetting setting = IntToContentSetting(
-        prefs_->GetInteger(prefs::kDesktopNotificationDefaultContentSetting));
-    SetContentSetting(
+    const base::Value* value = prefs_->FindPreference(
+        prefs::kDesktopNotificationDefaultContentSetting)->GetValue();
+    // Do not clear the old preference yet as long as we need to maintain
+    // backward compatibility.
+    SetWebsiteSetting(
         ContentSettingsPattern::Wildcard(),
         ContentSettingsPattern::Wildcard(),
         CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
         std::string(),
-        setting);
+        value->DeepCopy());
     prefs_->ClearPref(prefs::kDesktopNotificationDefaultContentSetting);
   }
 }
 
 void DefaultProvider::MigrateObsoleteGeolocationPref() {
   if (prefs_->HasPrefPath(prefs::kGeolocationDefaultContentSetting)) {
-    ContentSetting setting = IntToContentSetting(
-        prefs_->GetInteger(prefs::kGeolocationDefaultContentSetting));
+    const base::Value* value = prefs_->FindPreference(
+        prefs::kGeolocationDefaultContentSetting)->GetValue();
     // Do not clear the old preference yet as long as we need to maintain
     // backward compatibility.
-    SetContentSetting(
+    SetWebsiteSetting(
         ContentSettingsPattern::Wildcard(),
         ContentSettingsPattern::Wildcard(),
         CONTENT_SETTINGS_TYPE_GEOLOCATION,
         std::string(),
-        setting);
+        value->DeepCopy());
   }
 }
 
 }  // namespace content_settings