| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome/browser/content_settings/content_settings_default_provider.h" | |
| 6 | |
| 7 #include <string> | |
| 8 #include <vector> | |
| 9 | |
| 10 #include "base/auto_reset.h" | |
| 11 #include "base/basictypes.h" | |
| 12 #include "base/bind.h" | |
| 13 #include "base/command_line.h" | |
| 14 #include "base/metrics/histogram.h" | |
| 15 #include "base/prefs/pref_service.h" | |
| 16 #include "base/prefs/scoped_user_pref_update.h" | |
| 17 #include "chrome/browser/content_settings/content_settings_utils.h" | |
| 18 #include "chrome/common/pref_names.h" | |
| 19 #include "components/content_settings/core/browser/content_settings_rule.h" | |
| 20 #include "components/content_settings/core/common/content_settings.h" | |
| 21 #include "components/content_settings/core/common/content_settings_pattern.h" | |
| 22 #include "components/pref_registry/pref_registry_syncable.h" | |
| 23 #include "url/gurl.h" | |
| 24 | |
| 25 namespace { | |
| 26 | |
| 27 // The default setting for each content type. | |
| 28 const ContentSetting kDefaultSettings[] = { | |
| 29 CONTENT_SETTING_ALLOW, // CONTENT_SETTINGS_TYPE_COOKIES | |
| 30 CONTENT_SETTING_ALLOW, // CONTENT_SETTINGS_TYPE_IMAGES | |
| 31 CONTENT_SETTING_ALLOW, // CONTENT_SETTINGS_TYPE_JAVASCRIPT | |
| 32 CONTENT_SETTING_ALLOW, // CONTENT_SETTINGS_TYPE_PLUGINS | |
| 33 CONTENT_SETTING_BLOCK, // CONTENT_SETTINGS_TYPE_POPUPS | |
| 34 CONTENT_SETTING_ASK, // CONTENT_SETTINGS_TYPE_GEOLOCATION | |
| 35 CONTENT_SETTING_ASK, // CONTENT_SETTINGS_TYPE_NOTIFICATIONS | |
| 36 CONTENT_SETTING_DEFAULT, // CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE | |
| 37 CONTENT_SETTING_ASK, // CONTENT_SETTINGS_TYPE_FULLSCREEN | |
| 38 CONTENT_SETTING_ASK, // CONTENT_SETTINGS_TYPE_MOUSELOCK | |
| 39 CONTENT_SETTING_DEFAULT, // CONTENT_SETTINGS_TYPE_MIXEDSCRIPT | |
| 40 CONTENT_SETTING_ASK, // CONTENT_SETTINGS_TYPE_MEDIASTREAM | |
| 41 CONTENT_SETTING_ASK, // CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC | |
| 42 CONTENT_SETTING_ASK, // CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA | |
| 43 CONTENT_SETTING_DEFAULT, // CONTENT_SETTINGS_TYPE_PROTOCOL_HANDLERS | |
| 44 CONTENT_SETTING_ASK, // CONTENT_SETTINGS_TYPE_PPAPI_BROKER | |
| 45 CONTENT_SETTING_ASK, // CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS | |
| 46 CONTENT_SETTING_ASK, // CONTENT_SETTINGS_TYPE_MIDI_SYSEX | |
| 47 CONTENT_SETTING_ASK, // CONTENT_SETTINGS_TYPE_PUSH_MESSAGING | |
| 48 CONTENT_SETTING_ALLOW, // CONTENT_SETTINGS_TYPE_SSL_CERT_DECISIONS | |
| 49 #if defined(OS_WIN) | |
| 50 CONTENT_SETTING_ASK, // CONTENT_SETTINGS_TYPE_METRO_SWITCH_TO_DESKTOP | |
| 51 #elif defined(OS_ANDROID) || defined(OS_CHROMEOS) | |
| 52 CONTENT_SETTING_ASK, // CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER | |
| 53 #endif | |
| 54 #if defined(OS_ANDROID) | |
| 55 CONTENT_SETTING_DEFAULT, // CONTENT_SETTINGS_TYPE_APP_BANNER | |
| 56 #endif | |
| 57 }; | |
| 58 COMPILE_ASSERT(arraysize(kDefaultSettings) == CONTENT_SETTINGS_NUM_TYPES, | |
| 59 default_settings_incorrect_size); | |
| 60 | |
| 61 } // namespace | |
| 62 | |
| 63 namespace content_settings { | |
| 64 | |
| 65 namespace { | |
| 66 | |
| 67 class DefaultRuleIterator : public RuleIterator { | |
| 68 public: | |
| 69 explicit DefaultRuleIterator(const base::Value* value) { | |
| 70 if (value) | |
| 71 value_.reset(value->DeepCopy()); | |
| 72 } | |
| 73 | |
| 74 bool HasNext() const override { return value_.get() != NULL; } | |
| 75 | |
| 76 Rule Next() override { | |
| 77 DCHECK(value_.get()); | |
| 78 return Rule(ContentSettingsPattern::Wildcard(), | |
| 79 ContentSettingsPattern::Wildcard(), | |
| 80 value_.release()); | |
| 81 } | |
| 82 | |
| 83 private: | |
| 84 scoped_ptr<base::Value> value_; | |
| 85 }; | |
| 86 | |
| 87 } // namespace | |
| 88 | |
| 89 // static | |
| 90 void DefaultProvider::RegisterProfilePrefs( | |
| 91 user_prefs::PrefRegistrySyncable* registry) { | |
| 92 // The registration of the preference prefs::kDefaultContentSettings should | |
| 93 // also include the default values for default content settings. This allows | |
| 94 // functional tests to get default content settings by reading the preference | |
| 95 // prefs::kDefaultContentSettings via pyauto. | |
| 96 // TODO(markusheintz): Write pyauto hooks for the content settings map as | |
| 97 // content settings should be read from the host content settings map. | |
| 98 base::DictionaryValue* default_content_settings = new base::DictionaryValue(); | |
| 99 registry->RegisterDictionaryPref( | |
| 100 prefs::kDefaultContentSettings, | |
| 101 default_content_settings, | |
| 102 user_prefs::PrefRegistrySyncable::SYNCABLE_PREF); | |
| 103 } | |
| 104 | |
| 105 DefaultProvider::DefaultProvider(PrefService* prefs, bool incognito) | |
| 106 : prefs_(prefs), | |
| 107 is_incognito_(incognito), | |
| 108 updating_preferences_(false) { | |
| 109 DCHECK(prefs_); | |
| 110 | |
| 111 // Read global defaults. | |
| 112 ReadDefaultSettings(true); | |
| 113 | |
| 114 UMA_HISTOGRAM_ENUMERATION( | |
| 115 "ContentSettings.DefaultCookiesSetting", | |
| 116 ValueToContentSetting( | |
| 117 default_settings_[CONTENT_SETTINGS_TYPE_COOKIES].get()), | |
| 118 CONTENT_SETTING_NUM_SETTINGS); | |
| 119 UMA_HISTOGRAM_ENUMERATION( | |
| 120 "ContentSettings.DefaultImagesSetting", | |
| 121 ValueToContentSetting( | |
| 122 default_settings_[CONTENT_SETTINGS_TYPE_IMAGES].get()), | |
| 123 CONTENT_SETTING_NUM_SETTINGS); | |
| 124 UMA_HISTOGRAM_ENUMERATION( | |
| 125 "ContentSettings.DefaultJavaScriptSetting", | |
| 126 ValueToContentSetting( | |
| 127 default_settings_[CONTENT_SETTINGS_TYPE_JAVASCRIPT].get()), | |
| 128 CONTENT_SETTING_NUM_SETTINGS); | |
| 129 UMA_HISTOGRAM_ENUMERATION( | |
| 130 "ContentSettings.DefaultPluginsSetting", | |
| 131 ValueToContentSetting( | |
| 132 default_settings_[CONTENT_SETTINGS_TYPE_PLUGINS].get()), | |
| 133 CONTENT_SETTING_NUM_SETTINGS); | |
| 134 UMA_HISTOGRAM_ENUMERATION( | |
| 135 "ContentSettings.DefaultPopupsSetting", | |
| 136 ValueToContentSetting( | |
| 137 default_settings_[CONTENT_SETTINGS_TYPE_POPUPS].get()), | |
| 138 CONTENT_SETTING_NUM_SETTINGS); | |
| 139 UMA_HISTOGRAM_ENUMERATION( | |
| 140 "ContentSettings.DefaultLocationSetting", | |
| 141 ValueToContentSetting( | |
| 142 default_settings_[CONTENT_SETTINGS_TYPE_GEOLOCATION].get()), | |
| 143 CONTENT_SETTING_NUM_SETTINGS); | |
| 144 UMA_HISTOGRAM_ENUMERATION( | |
| 145 "ContentSettings.DefaultNotificationsSetting", | |
| 146 ValueToContentSetting( | |
| 147 default_settings_[CONTENT_SETTINGS_TYPE_NOTIFICATIONS].get()), | |
| 148 CONTENT_SETTING_NUM_SETTINGS); | |
| 149 UMA_HISTOGRAM_ENUMERATION( | |
| 150 "ContentSettings.DefaultMouseCursorSetting", | |
| 151 ValueToContentSetting( | |
| 152 default_settings_[CONTENT_SETTINGS_TYPE_MOUSELOCK].get()), | |
| 153 CONTENT_SETTING_NUM_SETTINGS); | |
| 154 UMA_HISTOGRAM_ENUMERATION( | |
| 155 "ContentSettings.DefaultMediaStreamSetting", | |
| 156 ValueToContentSetting( | |
| 157 default_settings_[CONTENT_SETTINGS_TYPE_MEDIASTREAM].get()), | |
| 158 CONTENT_SETTING_NUM_SETTINGS); | |
| 159 UMA_HISTOGRAM_ENUMERATION( | |
| 160 "ContentSettings.DefaultMIDISysExSetting", | |
| 161 ValueToContentSetting( | |
| 162 default_settings_[CONTENT_SETTINGS_TYPE_MIDI_SYSEX].get()), | |
| 163 CONTENT_SETTING_NUM_SETTINGS); | |
| 164 UMA_HISTOGRAM_ENUMERATION( | |
| 165 "ContentSettings.DefaultPushMessagingSetting", | |
| 166 ValueToContentSetting( | |
| 167 default_settings_[CONTENT_SETTINGS_TYPE_PUSH_MESSAGING].get()), | |
| 168 CONTENT_SETTING_NUM_SETTINGS); | |
| 169 | |
| 170 pref_change_registrar_.Init(prefs_); | |
| 171 PrefChangeRegistrar::NamedChangeCallback callback = base::Bind( | |
| 172 &DefaultProvider::OnPreferenceChanged, base::Unretained(this)); | |
| 173 pref_change_registrar_.Add(prefs::kDefaultContentSettings, callback); | |
| 174 } | |
| 175 | |
| 176 DefaultProvider::~DefaultProvider() { | |
| 177 } | |
| 178 | |
| 179 bool DefaultProvider::SetWebsiteSetting( | |
| 180 const ContentSettingsPattern& primary_pattern, | |
| 181 const ContentSettingsPattern& secondary_pattern, | |
| 182 ContentSettingsType content_type, | |
| 183 const ResourceIdentifier& resource_identifier, | |
| 184 base::Value* in_value) { | |
| 185 DCHECK(CalledOnValidThread()); | |
| 186 DCHECK(prefs_); | |
| 187 | |
| 188 // Ignore non default settings | |
| 189 if (primary_pattern != ContentSettingsPattern::Wildcard() || | |
| 190 secondary_pattern != ContentSettingsPattern::Wildcard()) { | |
| 191 return false; | |
| 192 } | |
| 193 | |
| 194 // The default settings may not be directly modified for OTR sessions. | |
| 195 // Instead, they are synced to the main profile's setting. | |
| 196 if (is_incognito_) | |
| 197 return false; | |
| 198 | |
| 199 // Put |in_value| in a scoped pointer to ensure that it gets cleaned up | |
| 200 // properly if we don't pass on the ownership. | |
| 201 scoped_ptr<base::Value> value(in_value); | |
| 202 { | |
| 203 base::AutoReset<bool> auto_reset(&updating_preferences_, true); | |
| 204 | |
| 205 // |DefaultProvider| should not send any notifications when holding | |
| 206 // |lock_|. |DictionaryPrefUpdate| destructor and | |
| 207 // |PrefService::SetInteger()| send out notifications. As a response, the | |
| 208 // upper layers may call |GetAllContentSettingRules| which acquires |lock_| | |
| 209 // again. | |
| 210 DictionaryPrefUpdate update(prefs_, prefs::kDefaultContentSettings); | |
| 211 base::DictionaryValue* default_settings_dictionary = update.Get(); | |
| 212 base::AutoLock lock(lock_); | |
| 213 if (value.get() == NULL || | |
| 214 ValueToContentSetting(value.get()) == kDefaultSettings[content_type]) { | |
| 215 // If |value| is NULL we need to reset the default setting the the | |
| 216 // hardcoded default. | |
| 217 default_settings_[content_type].reset( | |
| 218 new base::FundamentalValue(kDefaultSettings[content_type])); | |
| 219 | |
| 220 // Remove the corresponding pref entry since the hardcoded default value | |
| 221 // is used. | |
| 222 default_settings_dictionary->RemoveWithoutPathExpansion( | |
| 223 GetTypeName(content_type), NULL); | |
| 224 } else { | |
| 225 default_settings_[content_type].reset(value->DeepCopy()); | |
| 226 // Transfer ownership of |value| to the |default_settings_dictionary|. | |
| 227 default_settings_dictionary->SetWithoutPathExpansion( | |
| 228 GetTypeName(content_type), value.release()); | |
| 229 } | |
| 230 } | |
| 231 | |
| 232 NotifyObservers(ContentSettingsPattern(), | |
| 233 ContentSettingsPattern(), | |
| 234 content_type, | |
| 235 std::string()); | |
| 236 | |
| 237 return true; | |
| 238 } | |
| 239 | |
| 240 RuleIterator* DefaultProvider::GetRuleIterator( | |
| 241 ContentSettingsType content_type, | |
| 242 const ResourceIdentifier& resource_identifier, | |
| 243 bool incognito) const { | |
| 244 base::AutoLock lock(lock_); | |
| 245 if (resource_identifier.empty()) { | |
| 246 ValueMap::const_iterator it(default_settings_.find(content_type)); | |
| 247 if (it != default_settings_.end()) { | |
| 248 return new DefaultRuleIterator(it->second.get()); | |
| 249 } | |
| 250 NOTREACHED(); | |
| 251 } | |
| 252 return new EmptyRuleIterator(); | |
| 253 } | |
| 254 | |
| 255 void DefaultProvider::ClearAllContentSettingsRules( | |
| 256 ContentSettingsType content_type) { | |
| 257 // TODO(markusheintz): This method is only called when the | |
| 258 // |DesktopNotificationService| calls |ClearAllSettingsForType| method on the | |
| 259 // |HostContentSettingsMap|. Don't implement this method yet, otherwise the | |
| 260 // default notification settings will be cleared as well. | |
| 261 } | |
| 262 | |
| 263 void DefaultProvider::ShutdownOnUIThread() { | |
| 264 DCHECK(CalledOnValidThread()); | |
| 265 DCHECK(prefs_); | |
| 266 RemoveAllObservers(); | |
| 267 pref_change_registrar_.RemoveAll(); | |
| 268 prefs_ = NULL; | |
| 269 } | |
| 270 | |
| 271 void DefaultProvider::OnPreferenceChanged(const std::string& name) { | |
| 272 DCHECK(CalledOnValidThread()); | |
| 273 if (updating_preferences_) | |
| 274 return; | |
| 275 | |
| 276 if (name == prefs::kDefaultContentSettings) { | |
| 277 ReadDefaultSettings(true); | |
| 278 } else { | |
| 279 NOTREACHED() << "Unexpected preference observed"; | |
| 280 return; | |
| 281 } | |
| 282 | |
| 283 NotifyObservers(ContentSettingsPattern(), | |
| 284 ContentSettingsPattern(), | |
| 285 CONTENT_SETTINGS_TYPE_DEFAULT, | |
| 286 std::string()); | |
| 287 } | |
| 288 | |
| 289 void DefaultProvider::ReadDefaultSettings(bool overwrite) { | |
| 290 base::AutoLock lock(lock_); | |
| 291 const base::DictionaryValue* default_settings_dictionary = | |
| 292 prefs_->GetDictionary(prefs::kDefaultContentSettings); | |
| 293 | |
| 294 if (overwrite) | |
| 295 default_settings_.clear(); | |
| 296 | |
| 297 // Careful: The returned value could be NULL if the pref has never been set. | |
| 298 if (default_settings_dictionary) | |
| 299 GetSettingsFromDictionary(default_settings_dictionary); | |
| 300 | |
| 301 ForceDefaultsToBeExplicit(); | |
| 302 } | |
| 303 | |
| 304 void DefaultProvider::ForceDefaultsToBeExplicit() { | |
| 305 for (int i = 0; i < CONTENT_SETTINGS_NUM_TYPES; ++i) { | |
| 306 ContentSettingsType type = ContentSettingsType(i); | |
| 307 if (!default_settings_[type].get() && | |
| 308 kDefaultSettings[i] != CONTENT_SETTING_DEFAULT) { | |
| 309 default_settings_[type].reset( | |
| 310 new base::FundamentalValue(kDefaultSettings[i])); | |
| 311 } | |
| 312 } | |
| 313 } | |
| 314 | |
| 315 void DefaultProvider::GetSettingsFromDictionary( | |
| 316 const base::DictionaryValue* dictionary) { | |
| 317 for (base::DictionaryValue::Iterator i(*dictionary); | |
| 318 !i.IsAtEnd(); i.Advance()) { | |
| 319 const std::string& content_type(i.key()); | |
| 320 for (size_t type = 0; type < CONTENT_SETTINGS_NUM_TYPES; ++type) { | |
| 321 if (content_type == GetTypeName(ContentSettingsType(type))) { | |
| 322 int int_value = CONTENT_SETTING_DEFAULT; | |
| 323 bool is_integer = i.value().GetAsInteger(&int_value); | |
| 324 DCHECK(is_integer); | |
| 325 default_settings_[ContentSettingsType(type)].reset( | |
| 326 new base::FundamentalValue(int_value)); | |
| 327 break; | |
| 328 } | |
| 329 } | |
| 330 } | |
| 331 // Migrate obsolete cookie prompt mode. | |
| 332 if (ValueToContentSetting( | |
| 333 default_settings_[CONTENT_SETTINGS_TYPE_COOKIES].get()) == | |
| 334 CONTENT_SETTING_ASK) { | |
| 335 default_settings_[CONTENT_SETTINGS_TYPE_COOKIES].reset( | |
| 336 new base::FundamentalValue(CONTENT_SETTING_BLOCK)); | |
| 337 } | |
| 338 } | |
| 339 | |
| 340 } // namespace content_settings | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 670953006:
Componentize HostContentSettingsMap and content settings providers. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master