Take script URLs into account when applying script content settings.

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 91 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] ==
+  if (default_content_settings_[CONTENT_SETTINGS_TYPE_COOKIES] ==
       CONTENT_SETTING_BLOCK) {
     UserMetrics::RecordAction(
         UserMetricsAction("CookieBlockingEnabledPerDefault"));
   } else {
     UserMetrics::RecordAction(
         UserMetricsAction("CookieBlockingDisabledPerDefault"));
   }
 
   pref_change_registrar_.Init(prefs_);
   pref_change_registrar_.Add(prefs::kDefaultContentSettings, this);
@@ skipping 31 matching lines @@
 
     // |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.
     {
       base::AutoLock lock(lock_);
       if (setting == CONTENT_SETTING_DEFAULT ||
           setting == kDefaultSettings[content_type]) {
-        default_content_settings_.settings[content_type] =
+        default_content_settings_[content_type] =
             kDefaultSettings[content_type];
         default_settings_dictionary->RemoveWithoutPathExpansion(dictionary_path,
                                                                 NULL);
       } else {
-        default_content_settings_.settings[content_type] = setting;
+        default_content_settings_[content_type] = setting;
         default_settings_dictionary->SetWithoutPathExpansion(
             dictionary_path, Value::CreateIntegerValue(setting));
       }
     }
 
     // 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);
     }
   }
 
   NotifyObservers(ContentSettingsPattern(),
                   ContentSettingsPattern(),
                   content_type,
                   std::string());
 }
 
 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]);
+    return new DefaultRuleIterator(default_content_settings_[content_type]);
   } 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 39 matching lines @@
   } else {
     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();
+  if (overwrite) {
+    for (int i = 0; i < CONTENT_SETTINGS_NUM_TYPES; ++i)
+      default_content_settings_[i] = CONTENT_SETTING_DEFAULT;
+  }
 
   // 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_);
+                              default_content_settings_);
   }
   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];
+    if (default_content_settings_[i] == CONTENT_SETTING_DEFAULT)
+      default_content_settings_[i] = kDefaultSettings[i];
   }
 }
 
 void DefaultProvider::GetSettingsFromDictionary(
     const DictionaryValue* dictionary,
-    ContentSettings* settings) {
+    ContentSetting* settings) {
   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;
         bool found = dictionary->GetIntegerWithoutPathExpansion(content_type,
                                                                 &setting);
         DCHECK(found);
-        settings->settings[type] = IntToContentSetting(setting);
+        settings[type] = IntToContentSetting(setting);
         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;
+  if (settings[CONTENT_SETTINGS_TYPE_COOKIES] == CONTENT_SETTING_ASK)
+    settings[CONTENT_SETTINGS_TYPE_COOKIES] = CONTENT_SETTING_BLOCK;
 
-  settings->settings[CONTENT_SETTINGS_TYPE_PLUGINS] =
+  settings[CONTENT_SETTINGS_TYPE_PLUGINS] =
       ClickToPlayFixup(CONTENT_SETTINGS_TYPE_PLUGINS,
-                       settings->settings[CONTENT_SETTINGS_TYPE_PLUGINS]);
+                       settings[CONTENT_SETTINGS_TYPE_PLUGINS]);
 }
 
 void DefaultProvider::MigrateObsoleteNotificationPref() {
   if (prefs_->HasPrefPath(prefs::kDesktopNotificationDefaultContentSetting)) {
     ContentSetting setting = IntToContentSetting(
         prefs_->GetInteger(prefs::kDesktopNotificationDefaultContentSetting));
     SetContentSetting(
         ContentSettingsPattern::Wildcard(),
         ContentSettingsPattern::Wildcard(),
         CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
@@ skipping 12 matching lines @@
     SetContentSetting(
         ContentSettingsPattern::Wildcard(),
         ContentSettingsPattern::Wildcard(),
         CONTENT_SETTINGS_TYPE_GEOLOCATION,
         std::string(),
         setting);
   }
 }
 
 }  // namespace content_settings