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