1 // Copyright (c) 2011 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 #ifndef CHROME_BROWSER_CONTENT_SETTINGS_CONTENT_SETTINGS_PREF_PROVIDER_H_ 6 #define CHROME_BROWSER_CONTENT_SETTINGS_CONTENT_SETTINGS_PREF_PROVIDER_H_ 7 #pragma once 8 9 // A content settings provider that takes its settings out of the pref service. 10 11 #include <map> 12 #include <string> 13 #include <utility> 14 15 #include "base/basictypes.h" 16 #include "base/synchronization/lock.h" 17 #include "chrome/browser/content_settings/content_settings_base_provider.h" 18 #include "chrome/browser/content_settings/content_settings_provider.h" 19 #include "chrome/browser/prefs/pref_change_registrar.h" 20 #include "content/common/notification_observer.h" 21 #include "content/common/notification_registrar.h" 22 23 class ContentSettingsDetails; 24 class DictionaryValue; 25 class PrefService; 26 class Profile; 27 28 namespace content_settings { 29 30 // Content settings provider that provides default content settings based on 31 // user prefs. 32 class PrefDefaultProvider : public DefaultProviderInterface, 33 public NotificationObserver { 34 public: 35 explicit PrefDefaultProvider(Profile* profile); 36 virtual ~PrefDefaultProvider(); 37 38 // DefaultContentSettingsProvider implementation. 39 virtual ContentSetting ProvideDefaultSetting( 40 ContentSettingsType content_type) const; 41 virtual void UpdateDefaultSetting(ContentSettingsType content_type, 42 ContentSetting setting); 43 virtual void ResetToDefaults(); 44 virtual bool DefaultSettingIsManaged(ContentSettingsType content_type) const; 45 46 static void RegisterUserPrefs(PrefService* prefs); 47 48 // NotificationObserver implementation. 49 virtual void Observe(NotificationType type, 50 const NotificationSource& source, 51 const NotificationDetails& details); 52 53 private: 54 // Informs observers that content settings have changed. Make sure that 55 // |lock_| is not held when calling this, as listeners will usually call one 56 // of the GetSettings functions in response, which would then lead to a 57 // mutex deadlock. 58 void NotifyObservers(const ContentSettingsDetails& details); 59 60 void UnregisterObservers(); 61 62 // Sets the fields of |settings| based on the values in |dictionary|. 63 void GetSettingsFromDictionary(const DictionaryValue* dictionary, 64 ContentSettings* settings); 65 66 // Forces the default settings to be explicitly set instead of themselves 67 // being CONTENT_SETTING_DEFAULT. 68 void ForceDefaultsToBeExplicit(); 69 70 // Reads the default settings from the preferences service. If |overwrite| is 71 // true and the preference is missing, the local copy will be cleared as well. 72 void ReadDefaultSettings(bool overwrite); 73 74 void MigrateObsoleteNotificationPref(PrefService* prefs); 75 76 // Copies of the pref data, so that we can read it on the IO thread. 77 ContentSettings default_content_settings_; 78 79 Profile* profile_; 80 81 // Whether this settings map is for an Incognito session. 82 bool is_incognito_; 83 84 // Used around accesses to the default_content_settings_ object to guarantee 85 // thread safety. 86 mutable base::Lock lock_; 87 88 PrefChangeRegistrar pref_change_registrar_; 89 NotificationRegistrar notification_registrar_; 90 91 // Whether we are currently updating preferences, this is used to ignore 92 // notifications from the preferences service that we triggered ourself. 93 bool updating_preferences_; 94 95 bool initializing_; 96 97 DISALLOW_COPY_AND_ASSIGN(PrefDefaultProvider); 98 }; 99 100 // Content settings provider that provides content settings from the user 101 // preference. 102 class PrefProvider : public BaseProvider, 103 public NotificationObserver { 104 public: 105 static void RegisterUserPrefs(PrefService* prefs); 106 107 explicit PrefProvider(Profile* profile); 108 virtual ~PrefProvider(); 109 110 // ContentSettingsProvider implementation. 111 virtual bool ContentSettingsTypeIsManaged( 112 ContentSettingsType content_type); 113 114 virtual void SetContentSetting( 115 const ContentSettingsPattern& requesting_pattern, 116 const ContentSettingsPattern& embedding_pattern, 117 ContentSettingsType content_type, 118 const ResourceIdentifier& resource_identifier, 119 ContentSetting content_setting); 120 121 virtual void ClearAllContentSettingsRules( 122 ContentSettingsType content_type); 123 124 virtual void ResetToDefaults(); 125 126 // BaseProvider implementations. 127 virtual void Init(); 128 129 // NotificationObserver implementation. 130 virtual void Observe(NotificationType type, 131 const NotificationSource& source, 132 const NotificationDetails& details); 133 134 private: 135 void ReadExceptions(bool overwrite); 136 137 // Various migration methods (old cookie, popup and per-host data gets 138 // migrated to the new format). 139 void MigrateObsoletePerhostPref(PrefService* prefs); 140 void MigrateObsoletePopupsPref(PrefService* prefs); 141 142 void CanonicalizeContentSettingsExceptions( 143 DictionaryValue* all_settings_dictionary); 144 145 void GetSettingsFromDictionary( 146 const DictionaryValue* dictionary, 147 ContentSettings* settings); 148 149 void GetResourceSettingsFromDictionary( 150 const DictionaryValue* dictionary, 151 ResourceContentSettings* settings); 152 153 void NotifyObservers(const ContentSettingsDetails& details); 154 155 void UnregisterObservers(); 156 157 Profile* profile_; 158 159 PrefChangeRegistrar pref_change_registrar_; 160 NotificationRegistrar notification_registrar_; 161 162 // Whether we are currently updating preferences, this is used to ignore 163 // notifications from the preferences service that we triggered ourself. 164 bool updating_preferences_; 165 166 // Do not fire any Notifications as long as we are in the constructor. 167 bool initializing_; 168 169 DISALLOW_COPY_AND_ASSIGN(PrefProvider); 170 }; 171 172 } // namespace content_settings 173 174 #endif // CHROME_BROWSER_CONTENT_SETTINGS_CONTENT_SETTINGS_PREF_PROVIDER_H_ 175