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 #include "chrome/browser/prefs/profile_pref_store_manager.h"
6
7 #include "base/bind.h"
8 #include "base/callback.h"
9 #include "base/file_util.h"
10 #include "base/json/json_file_value_serializer.h"
11 #include "base/logging.h"
12 #include "base/metrics/histogram.h"
13 #include "base/prefs/json_pref_store.h"
14 #include "base/prefs/persistent_pref_store.h"
15 #include "base/prefs/pref_registry_simple.h"
16 #include "chrome/browser/prefs/pref_hash_store_impl.h"
17 #include "chrome/browser/prefs/tracked/pref_service_hash_store_contents.h"
18 #include "chrome/browser/prefs/tracked/segregated_pref_store.h"
19 #include "chrome/browser/prefs/tracked/tracked_preferences_migration.h"
20 #include "chrome/common/chrome_constants.h"
21 #include "chrome/common/pref_names.h"
22 #include "components/pref_registry/pref_registry_syncable.h"
23
24 // TODO(erikwright): Enable this on Chrome OS and Android once MACs are moved
25 // out of Local State. This will resolve a race condition on Android and a
26 // privacy issue on ChromeOS. http://crbug.com/349158
27 const bool ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking =
28 #if defined(OS_ANDROID) || defined(OS_CHROMEOS)
29 false;
30 #else
31 true;
32 #endif
33
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)34 ProfilePrefStoreManager::ProfilePrefStoreManager(
35 const base::FilePath& profile_path,
36 const std::vector<PrefHashFilter::TrackedPreferenceMetadata>&
37 tracking_configuration,
38 size_t reporting_ids_count,
39 const std::string& seed,
40 const std::string& device_id,
41 PrefService* local_state)
42 : profile_path_(profile_path),
43 tracking_configuration_(tracking_configuration),
44 reporting_ids_count_(reporting_ids_count),
45 seed_(seed),
46 device_id_(device_id),
47 local_state_(local_state) {}
48
~ProfilePrefStoreManager()49 ProfilePrefStoreManager::~ProfilePrefStoreManager() {}
50
51 // static
RegisterPrefs(PrefRegistrySimple * registry)52 void ProfilePrefStoreManager::RegisterPrefs(PrefRegistrySimple* registry) {
53 PrefServiceHashStoreContents::RegisterPrefs(registry);
54 }
55
56 // static
RegisterProfilePrefs(user_prefs::PrefRegistrySyncable * registry)57 void ProfilePrefStoreManager::RegisterProfilePrefs(
58 user_prefs::PrefRegistrySyncable* registry) {
59 PrefHashFilter::RegisterProfilePrefs(registry);
60 }
61
62 // static
GetPrefFilePathFromProfilePath(const base::FilePath & profile_path)63 base::FilePath ProfilePrefStoreManager::GetPrefFilePathFromProfilePath(
64 const base::FilePath& profile_path) {
65 return profile_path.Append(chrome::kPreferencesFilename);
66 }
67
68 // static
ResetAllPrefHashStores(PrefService * local_state)69 void ProfilePrefStoreManager::ResetAllPrefHashStores(PrefService* local_state) {
70 PrefServiceHashStoreContents::ResetAllPrefHashStores(local_state);
71 }
72
73 // static
GetResetTime(PrefService * pref_service)74 base::Time ProfilePrefStoreManager::GetResetTime(PrefService* pref_service) {
75 return PrefHashFilter::GetResetTime(pref_service);
76 }
77
78 // static
ClearResetTime(PrefService * pref_service)79 void ProfilePrefStoreManager::ClearResetTime(PrefService* pref_service) {
80 PrefHashFilter::ClearResetTime(pref_service);
81 }
82
CreateProfilePrefStore(const scoped_refptr<base::SequencedTaskRunner> & io_task_runner,const base::Closure & on_reset_on_load,TrackedPreferenceValidationDelegate * validation_delegate)83 PersistentPrefStore* ProfilePrefStoreManager::CreateProfilePrefStore(
84 const scoped_refptr<base::SequencedTaskRunner>& io_task_runner,
85 const base::Closure& on_reset_on_load,
86 TrackedPreferenceValidationDelegate* validation_delegate) {
87 scoped_ptr<PrefFilter> pref_filter;
88 if (!kPlatformSupportsPreferenceTracking) {
89 return new JsonPrefStore(GetPrefFilePathFromProfilePath(profile_path_),
90 io_task_runner,
91 scoped_ptr<PrefFilter>());
92 }
93
94 std::vector<PrefHashFilter::TrackedPreferenceMetadata>
95 unprotected_configuration;
96 std::vector<PrefHashFilter::TrackedPreferenceMetadata>
97 protected_configuration;
98 std::set<std::string> protected_pref_names;
99 std::set<std::string> unprotected_pref_names;
100 for (std::vector<PrefHashFilter::TrackedPreferenceMetadata>::const_iterator
101 it = tracking_configuration_.begin();
102 it != tracking_configuration_.end();
103 ++it) {
104 if (it->enforcement_level > PrefHashFilter::NO_ENFORCEMENT) {
105 protected_configuration.push_back(*it);
106 protected_pref_names.insert(it->name);
107 } else {
108 unprotected_configuration.push_back(*it);
109 unprotected_pref_names.insert(it->name);
110 }
111 }
112
113 scoped_ptr<PrefHashFilter> unprotected_pref_hash_filter(
114 new PrefHashFilter(GetPrefHashStore(false),
115 unprotected_configuration,
116 base::Closure(),
117 validation_delegate,
118 reporting_ids_count_,
119 false));
120 scoped_ptr<PrefHashFilter> protected_pref_hash_filter(
121 new PrefHashFilter(GetPrefHashStore(true),
122 protected_configuration,
123 on_reset_on_load,
124 validation_delegate,
125 reporting_ids_count_,
126 true));
127
128 PrefHashFilter* raw_unprotected_pref_hash_filter =
129 unprotected_pref_hash_filter.get();
130 PrefHashFilter* raw_protected_pref_hash_filter =
131 protected_pref_hash_filter.get();
132
133 scoped_refptr<JsonPrefStore> unprotected_pref_store(
134 new JsonPrefStore(GetPrefFilePathFromProfilePath(profile_path_),
135 io_task_runner,
136 unprotected_pref_hash_filter.PassAs<PrefFilter>()));
137 // TODO(gab): Remove kDeprecatedProtectedPreferencesFilename as an alternate
138 // file in M40+.
139 scoped_refptr<JsonPrefStore> protected_pref_store(new JsonPrefStore(
140 profile_path_.Append(chrome::kSecurePreferencesFilename),
141 profile_path_.Append(chrome::kProtectedPreferencesFilenameDeprecated),
142 io_task_runner,
143 protected_pref_hash_filter.PassAs<PrefFilter>()));
144
145 SetupTrackedPreferencesMigration(
146 unprotected_pref_names,
147 protected_pref_names,
148 base::Bind(&JsonPrefStore::RemoveValueSilently,
149 unprotected_pref_store->AsWeakPtr()),
150 base::Bind(&JsonPrefStore::RemoveValueSilently,
151 protected_pref_store->AsWeakPtr()),
152 base::Bind(&JsonPrefStore::RegisterOnNextSuccessfulWriteCallback,
153 unprotected_pref_store->AsWeakPtr()),
154 base::Bind(&JsonPrefStore::RegisterOnNextSuccessfulWriteCallback,
155 protected_pref_store->AsWeakPtr()),
156 GetPrefHashStore(false),
157 GetPrefHashStore(true),
158 scoped_ptr<HashStoreContents>(new PrefServiceHashStoreContents(
159 profile_path_.AsUTF8Unsafe(), local_state_)),
160 raw_unprotected_pref_hash_filter,
161 raw_protected_pref_hash_filter);
162
163 return new SegregatedPrefStore(unprotected_pref_store, protected_pref_store,
164 protected_pref_names);
165 }
166
InitializePrefsFromMasterPrefs(const base::DictionaryValue & master_prefs)167 bool ProfilePrefStoreManager::InitializePrefsFromMasterPrefs(
168 const base::DictionaryValue& master_prefs) {
169 // Create the profile directory if it doesn't exist yet (very possible on
170 // first run).
171 if (!base::CreateDirectory(profile_path_))
172 return false;
173
174 const base::DictionaryValue* to_serialize = &master_prefs;
175 scoped_ptr<base::DictionaryValue> copy;
176
177 if (kPlatformSupportsPreferenceTracking) {
178 copy.reset(master_prefs.DeepCopy());
179 to_serialize = copy.get();
180 PrefHashFilter(GetPrefHashStore(false),
181 tracking_configuration_,
182 base::Closure(),
183 NULL,
184 reporting_ids_count_,
185 false).Initialize(copy.get());
186 }
187
188 // This will write out to a single combined file which will be immediately
189 // migrated to two files on load.
190 JSONFileValueSerializer serializer(
191 GetPrefFilePathFromProfilePath(profile_path_));
192
193 // Call Serialize (which does IO) on the main thread, which would _normally_
194 // be verboten. In this case however, we require this IO to synchronously
195 // complete before Chrome can start (as master preferences seed the Local
196 // State and Preferences files). This won't trip ThreadIORestrictions as they
197 // won't have kicked in yet on the main thread.
198 bool success = serializer.Serialize(*to_serialize);
199
200 UMA_HISTOGRAM_BOOLEAN("Settings.InitializedFromMasterPrefs", success);
201 return success;
202 }
203
204 PersistentPrefStore*
CreateDeprecatedCombinedProfilePrefStore(const scoped_refptr<base::SequencedTaskRunner> & io_task_runner)205 ProfilePrefStoreManager::CreateDeprecatedCombinedProfilePrefStore(
206 const scoped_refptr<base::SequencedTaskRunner>& io_task_runner) {
207 scoped_ptr<PrefFilter> pref_filter;
208 if (kPlatformSupportsPreferenceTracking) {
209 scoped_ptr<PrefHashStoreImpl> pref_hash_store_impl(
210 new PrefHashStoreImpl(seed_, device_id_, true));
211 pref_hash_store_impl->set_legacy_hash_store_contents(
212 scoped_ptr<HashStoreContents>(new PrefServiceHashStoreContents(
213 profile_path_.AsUTF8Unsafe(), local_state_)));
214 pref_filter.reset(
215 new PrefHashFilter(pref_hash_store_impl.PassAs<PrefHashStore>(),
216 tracking_configuration_,
217 base::Closure(),
218 NULL,
219 reporting_ids_count_,
220 false));
221 }
222 return new JsonPrefStore(GetPrefFilePathFromProfilePath(profile_path_),
223 io_task_runner,
224 pref_filter.Pass());
225 }
226
GetPrefHashStore(bool use_super_mac)227 scoped_ptr<PrefHashStore> ProfilePrefStoreManager::GetPrefHashStore(
228 bool use_super_mac) {
229 DCHECK(kPlatformSupportsPreferenceTracking);
230
231 return scoped_ptr<PrefHashStore>(new PrefHashStoreImpl(
232 seed_,
233 device_id_,
234 use_super_mac));
235 }
236