1 // Copyright 2013 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_PREFS_PREF_HASH_FILTER_H_ 6 #define CHROME_BROWSER_PREFS_PREF_HASH_FILTER_H_ 7 8 #include <map> 9 #include <set> 10 #include <vector> 11 12 #include "base/basictypes.h" 13 #include "base/callback.h" 14 #include "base/compiler_specific.h" 15 #include "base/containers/scoped_ptr_hash_map.h" 16 #include "base/memory/scoped_ptr.h" 17 #include "chrome/browser/prefs/interceptable_pref_filter.h" 18 #include "chrome/browser/prefs/tracked/tracked_preference.h" 19 20 class PrefHashStore; 21 class PrefService; 22 class PrefStore; 23 class TrackedPreferenceValidationDelegate; 24 25 namespace base { 26 class DictionaryValue; 27 class Time; 28 class Value; 29 } // namespace base 30 31 namespace user_prefs { 32 class PrefRegistrySyncable; 33 } // namespace user_prefs 34 35 // Intercepts preference values as they are loaded from disk and verifies them 36 // using a PrefHashStore. Keeps the PrefHashStore contents up to date as values 37 // are changed. 38 class PrefHashFilter : public InterceptablePrefFilter { 39 public: 40 enum EnforcementLevel { 41 NO_ENFORCEMENT, 42 ENFORCE_ON_LOAD 43 }; 44 45 enum PrefTrackingStrategy { 46 // Atomic preferences are tracked as a whole. 47 TRACKING_STRATEGY_ATOMIC, 48 // Split preferences are dictionaries for which each top-level entry is 49 // tracked independently. Note: preferences using this strategy must be kept 50 // in sync with TrackedSplitPreferences in histograms.xml. 51 TRACKING_STRATEGY_SPLIT, 52 }; 53 54 struct TrackedPreferenceMetadata { 55 size_t reporting_id; 56 const char* name; 57 EnforcementLevel enforcement_level; 58 PrefTrackingStrategy strategy; 59 }; 60 61 // Constructs a PrefHashFilter tracking the specified |tracked_preferences| 62 // using |pref_hash_store| to check/store hashes. An optional |delegate| is 63 // notified of the status of each preference as it is checked. 64 // If |on_reset_on_load| is provided, it will be invoked if a reset occurs in 65 // FilterOnLoad. 66 // |reporting_ids_count| is the count of all possible IDs (possibly greater 67 // than |tracked_preferences.size()|). If |report_super_mac_validity| is true, 68 // the state of the super MAC will be reported via UMA during 69 // FinalizeFilterOnLoad. 70 PrefHashFilter( 71 scoped_ptr<PrefHashStore> pref_hash_store, 72 const std::vector<TrackedPreferenceMetadata>& tracked_preferences, 73 const base::Closure& on_reset_on_load, 74 TrackedPreferenceValidationDelegate* delegate, 75 size_t reporting_ids_count, 76 bool report_super_mac_validity); 77 78 virtual ~PrefHashFilter(); 79 80 // Registers required user preferences. 81 static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry); 82 83 // Retrieves the time of the last reset event, if any, for the provided user 84 // preferences. If no reset has occurred, Returns a null |Time|. 85 static base::Time GetResetTime(PrefService* user_prefs); 86 87 // Clears the time of the last reset event, if any, for the provided user 88 // preferences. 89 static void ClearResetTime(PrefService* user_prefs); 90 91 // Initializes the PrefHashStore with hashes of the tracked preferences in 92 // |pref_store_contents|. |pref_store_contents| will be the |storage| passed 93 // to PrefHashStore::BeginTransaction(). 94 void Initialize(base::DictionaryValue* pref_store_contents); 95 96 // PrefFilter remaining implementation. 97 virtual void FilterUpdate(const std::string& path) OVERRIDE; 98 virtual void FilterSerializeData( 99 base::DictionaryValue* pref_store_contents) OVERRIDE; 100 101 private: 102 // InterceptablePrefFilter implementation. 103 virtual void FinalizeFilterOnLoad( 104 const PostFilterOnLoadCallback& post_filter_on_load_callback, 105 scoped_ptr<base::DictionaryValue> pref_store_contents, 106 bool prefs_altered) OVERRIDE; 107 108 // Callback to be invoked only once (and subsequently reset) on the next 109 // FilterOnLoad event. It will be allowed to modify the |prefs| handed to 110 // FilterOnLoad before handing them back to this PrefHashFilter. 111 FilterOnLoadInterceptor filter_on_load_interceptor_; 112 113 // A map of paths to TrackedPreferences; this map owns this individual 114 // TrackedPreference objects. 115 typedef base::ScopedPtrHashMap<std::string, TrackedPreference> 116 TrackedPreferencesMap; 117 // A map from changed paths to their corresponding TrackedPreferences (which 118 // aren't owned by this map). 119 typedef std::map<std::string, const TrackedPreference*> ChangedPathsMap; 120 121 scoped_ptr<PrefHashStore> pref_hash_store_; 122 123 // Invoked if a reset occurs in a call to FilterOnLoad. 124 const base::Closure on_reset_on_load_; 125 126 TrackedPreferencesMap tracked_paths_; 127 128 // The set of all paths whose value has changed since the last call to 129 // FilterSerializeData. 130 ChangedPathsMap changed_paths_; 131 132 // Whether to report the validity of the super MAC at load time (via UMA). 133 bool report_super_mac_validity_; 134 135 DISALLOW_COPY_AND_ASSIGN(PrefHashFilter); 136 }; 137 138 #endif // CHROME_BROWSER_PREFS_PREF_HASH_FILTER_H_ 139