1 // Copyright 2014 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_PROFILE_PREF_STORE_MANAGER_H_ 6 #define CHROME_BROWSER_PREFS_PROFILE_PREF_STORE_MANAGER_H_ 7 8 #include <string> 9 #include <vector> 10 11 #include "base/files/file_path.h" 12 #include "base/macros.h" 13 #include "base/memory/ref_counted.h" 14 #include "base/memory/scoped_ptr.h" 15 #include "chrome/browser/prefs/pref_hash_filter.h" 16 17 class PersistentPrefStore; 18 class PrefHashStore; 19 class PrefService; 20 class TrackedPreferenceValidationDelegate; 21 22 namespace base { 23 class DictionaryValue; 24 class SequencedTaskRunner; 25 } // namespace base 26 27 namespace user_prefs { 28 class PrefRegistrySyncable; 29 } // namespace user_prefs 30 31 class PrefRegistrySimple; 32 33 // Provides a facade through which the user preference store may be accessed and 34 // managed. 35 class ProfilePrefStoreManager { 36 public: 37 // Instantiates a ProfilePrefStoreManager with the configuration required to 38 // manage the user preferences of the profile at |profile_path|. 39 // |tracking_configuration| is used for preference tracking. 40 // |reporting_ids_count| is the count of all possible tracked preference IDs 41 // (possibly greater than |tracking_configuration.size()|). 42 // |seed| and |device_id| are used to track preference value changes and must 43 // be the same on each launch in order to verify loaded preference values. 44 ProfilePrefStoreManager( 45 const base::FilePath& profile_path, 46 const std::vector<PrefHashFilter::TrackedPreferenceMetadata>& 47 tracking_configuration, 48 size_t reporting_ids_count, 49 const std::string& seed, 50 const std::string& device_id, 51 PrefService* local_state); 52 53 ~ProfilePrefStoreManager(); 54 55 static const bool kPlatformSupportsPreferenceTracking; 56 57 // Register local state prefs used by the profile preferences system. 58 static void RegisterPrefs(PrefRegistrySimple* registry); 59 60 // Register user prefs used by the profile preferences system. 61 static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry); 62 63 // Determines the user preferences filename for the profile at |profile_path|. 64 static base::FilePath GetPrefFilePathFromProfilePath( 65 const base::FilePath& profile_path); 66 67 // Deletes stored hashes for all profiles from |local_state|. 68 static void ResetAllPrefHashStores(PrefService* local_state); 69 70 // Retrieves the time of the last preference reset event, if any, for 71 // |pref_service|. Assumes that |pref_service| is backed by a PrefStore that 72 // was built by ProfilePrefStoreManager. 73 // If no reset has occurred, returns a null |Time|. 74 static base::Time GetResetTime(PrefService* pref_service); 75 76 // Clears the time of the last preference reset event, if any, for 77 // |pref_service|. Assumes that |pref_service| is backed by a PrefStore that 78 // was built by ProfilePrefStoreManager. 79 static void ClearResetTime(PrefService* pref_service); 80 81 // Creates a PersistentPrefStore providing access to the user preferences of 82 // the managed profile. If |on_reset| is provided, it will be invoked if a 83 // reset occurs as a result of loading the profile's prefs. 84 // An optional |validation_delegate| will be notified 85 // of the status of each tracked preference as they are checked. 86 PersistentPrefStore* CreateProfilePrefStore( 87 const scoped_refptr<base::SequencedTaskRunner>& io_task_runner, 88 const base::Closure& on_reset_on_load, 89 TrackedPreferenceValidationDelegate* validation_delegate); 90 91 // Initializes the preferences for the managed profile with the preference 92 // values in |master_prefs|. Acts synchronously, including blocking IO. 93 // Returns true on success. 94 bool InitializePrefsFromMasterPrefs( 95 const base::DictionaryValue& master_prefs); 96 97 // Creates a single-file PrefStore as was used in M34 and earlier. Used only 98 // for testing migration. 99 PersistentPrefStore* CreateDeprecatedCombinedProfilePrefStore( 100 const scoped_refptr<base::SequencedTaskRunner>& io_task_runner); 101 102 private: 103 // Returns a PrefHashStore for the managed profile. Should only be called 104 // if |kPlatformSupportsPreferenceTracking|. |use_super_mac| determines 105 // whether the returned object will calculate, store, and validate super MACs 106 // (and, by extension, accept non-null newly protected preferences as 107 // TrustedInitialized). 108 scoped_ptr<PrefHashStore> GetPrefHashStore(bool use_super_mac); 109 110 const base::FilePath profile_path_; 111 const std::vector<PrefHashFilter::TrackedPreferenceMetadata> 112 tracking_configuration_; 113 const size_t reporting_ids_count_; 114 const std::string seed_; 115 const std::string device_id_; 116 PrefService* local_state_; 117 118 DISALLOW_COPY_AND_ASSIGN(ProfilePrefStoreManager); 119 }; 120 121 #endif // CHROME_BROWSER_PREFS_PROFILE_PREF_STORE_MANAGER_H_ 122