| OLD | NEW |
|---|
| (Empty) |
| 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/tracked/tracked_preferences_migration.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/callback.h" | |
| 9 #include "base/macros.h" | |
| 10 #include "base/memory/ref_counted.h" | |
| 11 #include "base/metrics/histogram.h" | |
| 12 #include "base/values.h" | |
| 13 #include "chrome/browser/prefs/tracked/dictionary_hash_store_contents.h" | |
| 14 #include "chrome/browser/prefs/tracked/hash_store_contents.h" | |
| 15 #include "chrome/browser/prefs/tracked/interceptable_pref_filter.h" | |
| 16 #include "chrome/browser/prefs/tracked/pref_hash_store.h" | |
| 17 #include "chrome/browser/prefs/tracked/pref_hash_store_transaction.h" | |
| 18 | |
| 19 namespace { | |
| 20 | |
| 21 class TrackedPreferencesMigrator | |
| 22 : public base::RefCounted<TrackedPreferencesMigrator> { | |
| 23 public: | |
| 24 TrackedPreferencesMigrator( | |
| 25 const std::set<std::string>& unprotected_pref_names, | |
| 26 const std::set<std::string>& protected_pref_names, | |
| 27 const base::Callback<void(const std::string& key)>& | |
| 28 unprotected_store_cleaner, | |
| 29 const base::Callback<void(const std::string& key)>& | |
| 30 protected_store_cleaner, | |
| 31 const base::Callback<void(const base::Closure&)>& | |
| 32 register_on_successful_unprotected_store_write_callback, | |
| 33 const base::Callback<void(const base::Closure&)>& | |
| 34 register_on_successful_protected_store_write_callback, | |
| 35 scoped_ptr<PrefHashStore> unprotected_pref_hash_store, | |
| 36 scoped_ptr<PrefHashStore> protected_pref_hash_store, | |
| 37 scoped_ptr<HashStoreContents> legacy_pref_hash_store, | |
| 38 InterceptablePrefFilter* unprotected_pref_filter, | |
| 39 InterceptablePrefFilter* protected_pref_filter); | |
| 40 | |
| 41 private: | |
| 42 friend class base::RefCounted<TrackedPreferencesMigrator>; | |
| 43 | |
| 44 enum PrefFilterID { | |
| 45 UNPROTECTED_PREF_FILTER, | |
| 46 PROTECTED_PREF_FILTER | |
| 47 }; | |
| 48 | |
| 49 ~TrackedPreferencesMigrator(); | |
| 50 | |
| 51 // Stores the data coming in from the filter identified by |id| into this | |
| 52 // class and then calls MigrateIfReady(); | |
| 53 void InterceptFilterOnLoad( | |
| 54 PrefFilterID id, | |
| 55 const InterceptablePrefFilter::FinalizeFilterOnLoadCallback& | |
| 56 finalize_filter_on_load, | |
| 57 scoped_ptr<base::DictionaryValue> prefs); | |
| 58 | |
| 59 // Proceeds with migration if both |unprotected_prefs_| and |protected_prefs_| | |
| 60 // have been set. | |
| 61 void MigrateIfReady(); | |
| 62 | |
| 63 const std::set<std::string> unprotected_pref_names_; | |
| 64 const std::set<std::string> protected_pref_names_; | |
| 65 | |
| 66 const base::Callback<void(const std::string& key)> unprotected_store_cleaner_; | |
| 67 const base::Callback<void(const std::string& key)> protected_store_cleaner_; | |
| 68 const base::Callback<void(const base::Closure&)> | |
| 69 register_on_successful_unprotected_store_write_callback_; | |
| 70 const base::Callback<void(const base::Closure&)> | |
| 71 register_on_successful_protected_store_write_callback_; | |
| 72 | |
| 73 InterceptablePrefFilter::FinalizeFilterOnLoadCallback | |
| 74 finalize_unprotected_filter_on_load_; | |
| 75 InterceptablePrefFilter::FinalizeFilterOnLoadCallback | |
| 76 finalize_protected_filter_on_load_; | |
| 77 | |
| 78 scoped_ptr<PrefHashStore> unprotected_pref_hash_store_; | |
| 79 scoped_ptr<PrefHashStore> protected_pref_hash_store_; | |
| 80 scoped_ptr<HashStoreContents> legacy_pref_hash_store_; | |
| 81 | |
| 82 scoped_ptr<base::DictionaryValue> unprotected_prefs_; | |
| 83 scoped_ptr<base::DictionaryValue> protected_prefs_; | |
| 84 | |
| 85 DISALLOW_COPY_AND_ASSIGN(TrackedPreferencesMigrator); | |
| 86 }; | |
| 87 | |
| 88 // Invokes |store_cleaner| for every |keys_to_clean|. | |
| 89 void CleanupPrefStore( | |
| 90 const base::Callback<void(const std::string& key)>& store_cleaner, | |
| 91 const std::set<std::string>& keys_to_clean) { | |
| 92 for (std::set<std::string>::const_iterator it = keys_to_clean.begin(); | |
| 93 it != keys_to_clean.end(); ++it) { | |
| 94 store_cleaner.Run(*it); | |
| 95 } | |
| 96 } | |
| 97 | |
| 98 // If |wait_for_commit_to_destination_store|: schedules (via | |
| 99 // |register_on_successful_destination_store_write_callback|) a cleanup of the | |
| 100 // |keys_to_clean| from the source pref store (through |source_store_cleaner|) | |
| 101 // once the destination pref store they were migrated to was successfully | |
| 102 // written to disk. Otherwise, executes the cleanup right away. | |
| 103 void ScheduleSourcePrefStoreCleanup( | |
| 104 const base::Callback<void(const base::Closure&)>& | |
| 105 register_on_successful_destination_store_write_callback, | |
| 106 const base::Callback<void(const std::string& key)>& source_store_cleaner, | |
| 107 const std::set<std::string>& keys_to_clean, | |
| 108 bool wait_for_commit_to_destination_store) { | |
| 109 DCHECK(!keys_to_clean.empty()); | |
| 110 if (wait_for_commit_to_destination_store) { | |
| 111 register_on_successful_destination_store_write_callback.Run( | |
| 112 base::Bind(&CleanupPrefStore, source_store_cleaner, keys_to_clean)); | |
| 113 } else { | |
| 114 CleanupPrefStore(source_store_cleaner, keys_to_clean); | |
| 115 } | |
| 116 } | |
| 117 | |
| 118 // Removes hashes for |migrated_pref_names| from |origin_pref_store| using | |
| 119 // the configuration/implementation in |origin_pref_hash_store|. | |
| 120 void CleanupMigratedHashes(const std::set<std::string>& migrated_pref_names, | |
| 121 PrefHashStore* origin_pref_hash_store, | |
| 122 base::DictionaryValue* origin_pref_store) { | |
| 123 scoped_ptr<PrefHashStoreTransaction> transaction( | |
| 124 origin_pref_hash_store->BeginTransaction(scoped_ptr<HashStoreContents>( | |
| 125 new DictionaryHashStoreContents(origin_pref_store)))); | |
| 126 for (std::set<std::string>::const_iterator it = migrated_pref_names.begin(); | |
| 127 it != migrated_pref_names.end(); | |
| 128 ++it) { | |
| 129 transaction->ClearHash(*it); | |
| 130 } | |
| 131 } | |
| 132 | |
| 133 // Copies the value of each pref in |pref_names| which is set in |old_store|, | |
| 134 // but not in |new_store| into |new_store|. Sets |old_store_needs_cleanup| to | |
| 135 // true if any old duplicates remain in |old_store| and sets |new_store_altered| | |
| 136 // to true if any value was copied to |new_store|. | |
| 137 void MigratePrefsFromOldToNewStore(const std::set<std::string>& pref_names, | |
| 138 base::DictionaryValue* old_store, | |
| 139 base::DictionaryValue* new_store, | |
| 140 PrefHashStore* new_hash_store, | |
| 141 HashStoreContents* legacy_hash_store, | |
| 142 bool* old_store_needs_cleanup, | |
| 143 bool* new_store_altered, | |
| 144 bool* used_legacy_pref_hashes) { | |
| 145 const base::DictionaryValue* old_hash_store_contents = | |
| 146 DictionaryHashStoreContents(old_store).GetContents(); | |
| 147 const base::DictionaryValue* legacy_hash_store_contents = | |
| 148 legacy_hash_store->GetContents(); | |
| 149 scoped_ptr<PrefHashStoreTransaction> new_hash_store_transaction( | |
| 150 new_hash_store->BeginTransaction(scoped_ptr<HashStoreContents>( | |
| 151 new DictionaryHashStoreContents(new_store)))); | |
| 152 | |
| 153 for (std::set<std::string>::const_iterator it = pref_names.begin(); | |
| 154 it != pref_names.end(); | |
| 155 ++it) { | |
| 156 const std::string& pref_name = *it; | |
| 157 const base::Value* value_in_old_store = NULL; | |
| 158 | |
| 159 // If the destination does not have a hash for this pref we will | |
| 160 // unconditionally attempt to move it. | |
| 161 bool destination_hash_missing = | |
| 162 !new_hash_store_transaction->HasHash(pref_name); | |
| 163 // If we migrate the value we will also attempt to migrate the hash. | |
| 164 bool migrated_value = false; | |
| 165 if (old_store->Get(pref_name, &value_in_old_store)) { | |
| 166 // Whether this value ends up being copied below or was left behind by a | |
| 167 // previous incomplete migration, it should be cleaned up. | |
| 168 *old_store_needs_cleanup = true; | |
| 169 | |
| 170 if (!new_store->Get(pref_name, NULL)) { | |
| 171 // Copy the value from |old_store| to |new_store| rather than moving it | |
| 172 // to avoid data loss should |old_store| be flushed to disk without | |
| 173 // |new_store| having equivalently been successfully flushed to disk | |
| 174 // (e.g., on crash or in cases where |new_store| is read-only following | |
| 175 // a read error on startup). | |
| 176 new_store->Set(pref_name, value_in_old_store->DeepCopy()); | |
| 177 migrated_value = true; | |
| 178 *new_store_altered = true; | |
| 179 } | |
| 180 } | |
| 181 | |
| 182 if (destination_hash_missing || migrated_value) { | |
| 183 const base::Value* old_hash = NULL; | |
| 184 if (old_hash_store_contents) | |
| 185 old_hash_store_contents->Get(pref_name, &old_hash); | |
| 186 if (!old_hash && legacy_hash_store_contents) { | |
| 187 legacy_hash_store_contents->Get(pref_name, &old_hash); | |
| 188 if (old_hash) | |
| 189 *used_legacy_pref_hashes = true; | |
| 190 } | |
| 191 if (old_hash) { | |
| 192 new_hash_store_transaction->ImportHash(pref_name, old_hash); | |
| 193 *new_store_altered = true; | |
| 194 } else if (!destination_hash_missing) { | |
| 195 // Do not allow values to be migrated without MACs if the destination | |
| 196 // already has a MAC (http://crbug.com/414554). Remove the migrated | |
| 197 // value in order to provide the same no-op behaviour as if the pref was | |
| 198 // added to the wrong file when there was already a value for | |
| 199 // |pref_name| in |new_store|. | |
| 200 new_store->Remove(pref_name, NULL); | |
| 201 *new_store_altered = true; | |
| 202 } | |
| 203 } | |
| 204 } | |
| 205 } | |
| 206 | |
| 207 TrackedPreferencesMigrator::TrackedPreferencesMigrator( | |
| 208 const std::set<std::string>& unprotected_pref_names, | |
| 209 const std::set<std::string>& protected_pref_names, | |
| 210 const base::Callback<void(const std::string& key)>& | |
| 211 unprotected_store_cleaner, | |
| 212 const base::Callback<void(const std::string& key)>& protected_store_cleaner, | |
| 213 const base::Callback<void(const base::Closure&)>& | |
| 214 register_on_successful_unprotected_store_write_callback, | |
| 215 const base::Callback<void(const base::Closure&)>& | |
| 216 register_on_successful_protected_store_write_callback, | |
| 217 scoped_ptr<PrefHashStore> unprotected_pref_hash_store, | |
| 218 scoped_ptr<PrefHashStore> protected_pref_hash_store, | |
| 219 scoped_ptr<HashStoreContents> legacy_pref_hash_store, | |
| 220 InterceptablePrefFilter* unprotected_pref_filter, | |
| 221 InterceptablePrefFilter* protected_pref_filter) | |
| 222 : unprotected_pref_names_(unprotected_pref_names), | |
| 223 protected_pref_names_(protected_pref_names), | |
| 224 unprotected_store_cleaner_(unprotected_store_cleaner), | |
| 225 protected_store_cleaner_(protected_store_cleaner), | |
| 226 register_on_successful_unprotected_store_write_callback_( | |
| 227 register_on_successful_unprotected_store_write_callback), | |
| 228 register_on_successful_protected_store_write_callback_( | |
| 229 register_on_successful_protected_store_write_callback), | |
| 230 unprotected_pref_hash_store_(unprotected_pref_hash_store.Pass()), | |
| 231 protected_pref_hash_store_(protected_pref_hash_store.Pass()), | |
| 232 legacy_pref_hash_store_(legacy_pref_hash_store.Pass()) { | |
| 233 // The callbacks bound below will own this TrackedPreferencesMigrator by | |
| 234 // reference. | |
| 235 unprotected_pref_filter->InterceptNextFilterOnLoad( | |
| 236 base::Bind(&TrackedPreferencesMigrator::InterceptFilterOnLoad, | |
| 237 this, | |
| 238 UNPROTECTED_PREF_FILTER)); | |
| 239 protected_pref_filter->InterceptNextFilterOnLoad( | |
| 240 base::Bind(&TrackedPreferencesMigrator::InterceptFilterOnLoad, | |
| 241 this, | |
| 242 PROTECTED_PREF_FILTER)); | |
| 243 } | |
| 244 | |
| 245 TrackedPreferencesMigrator::~TrackedPreferencesMigrator() {} | |
| 246 | |
| 247 void TrackedPreferencesMigrator::InterceptFilterOnLoad( | |
| 248 PrefFilterID id, | |
| 249 const InterceptablePrefFilter::FinalizeFilterOnLoadCallback& | |
| 250 finalize_filter_on_load, | |
| 251 scoped_ptr<base::DictionaryValue> prefs) { | |
| 252 switch (id) { | |
| 253 case UNPROTECTED_PREF_FILTER: | |
| 254 finalize_unprotected_filter_on_load_ = finalize_filter_on_load; | |
| 255 unprotected_prefs_ = prefs.Pass(); | |
| 256 break; | |
| 257 case PROTECTED_PREF_FILTER: | |
| 258 finalize_protected_filter_on_load_ = finalize_filter_on_load; | |
| 259 protected_prefs_ = prefs.Pass(); | |
| 260 break; | |
| 261 } | |
| 262 | |
| 263 MigrateIfReady(); | |
| 264 } | |
| 265 | |
| 266 void TrackedPreferencesMigrator::MigrateIfReady() { | |
| 267 // Wait for both stores to have been read before proceeding. | |
| 268 if (!protected_prefs_ || !unprotected_prefs_) | |
| 269 return; | |
| 270 | |
| 271 bool used_legacy_pref_hashes = false; | |
| 272 bool protected_prefs_need_cleanup = false; | |
| 273 bool unprotected_prefs_altered = false; | |
| 274 MigratePrefsFromOldToNewStore(unprotected_pref_names_, | |
| 275 protected_prefs_.get(), | |
| 276 unprotected_prefs_.get(), | |
| 277 unprotected_pref_hash_store_.get(), | |
| 278 legacy_pref_hash_store_.get(), | |
| 279 &protected_prefs_need_cleanup, | |
| 280 &unprotected_prefs_altered, | |
| 281 &used_legacy_pref_hashes); | |
| 282 bool unprotected_prefs_need_cleanup = false; | |
| 283 bool protected_prefs_altered = false; | |
| 284 MigratePrefsFromOldToNewStore(protected_pref_names_, | |
| 285 unprotected_prefs_.get(), | |
| 286 protected_prefs_.get(), | |
| 287 protected_pref_hash_store_.get(), | |
| 288 legacy_pref_hash_store_.get(), | |
| 289 &unprotected_prefs_need_cleanup, | |
| 290 &protected_prefs_altered, | |
| 291 &used_legacy_pref_hashes); | |
| 292 UMA_HISTOGRAM_BOOLEAN("Settings.MigratedHashesFromLocalState", | |
| 293 used_legacy_pref_hashes); | |
| 294 | |
| 295 if (!unprotected_prefs_altered && !protected_prefs_altered) { | |
| 296 // Clean up any MACs that might have been previously migrated from the | |
| 297 // various stores. It's safe to leave them behind for a little while as they | |
| 298 // will be ignored unless the corresponding value is _also_ present. The | |
| 299 // cleanup must be deferred until the MACs have been written to their target | |
| 300 // stores, and doing so in a subsequent launch is easier than within the | |
| 301 // same process. | |
| 302 CleanupMigratedHashes(unprotected_pref_names_, | |
| 303 protected_pref_hash_store_.get(), | |
| 304 protected_prefs_.get()); | |
| 305 CleanupMigratedHashes(protected_pref_names_, | |
| 306 unprotected_pref_hash_store_.get(), | |
| 307 unprotected_prefs_.get()); | |
| 308 legacy_pref_hash_store_->Reset(); | |
| 309 } | |
| 310 | |
| 311 // Hand the processed prefs back to their respective filters. | |
| 312 finalize_unprotected_filter_on_load_.Run(unprotected_prefs_.Pass(), | |
| 313 unprotected_prefs_altered); | |
| 314 finalize_protected_filter_on_load_.Run(protected_prefs_.Pass(), | |
| 315 protected_prefs_altered); | |
| 316 | |
| 317 if (unprotected_prefs_need_cleanup) { | |
| 318 // Schedule a cleanup of the |protected_pref_names_| from the unprotected | |
| 319 // prefs once the protected prefs were successfully written to disk (or | |
| 320 // do it immediately if |!protected_prefs_altered|). | |
| 321 ScheduleSourcePrefStoreCleanup( | |
| 322 register_on_successful_protected_store_write_callback_, | |
| 323 unprotected_store_cleaner_, | |
| 324 protected_pref_names_, | |
| 325 protected_prefs_altered); | |
| 326 } | |
| 327 | |
| 328 if (protected_prefs_need_cleanup) { | |
| 329 // Schedule a cleanup of the |unprotected_pref_names_| from the protected | |
| 330 // prefs once the unprotected prefs were successfully written to disk (or | |
| 331 // do it immediately if |!unprotected_prefs_altered|). | |
| 332 ScheduleSourcePrefStoreCleanup( | |
| 333 register_on_successful_unprotected_store_write_callback_, | |
| 334 protected_store_cleaner_, | |
| 335 unprotected_pref_names_, | |
| 336 unprotected_prefs_altered); | |
| 337 } | |
| 338 } | |
| 339 | |
| 340 } // namespace | |
| 341 | |
| 342 void SetupTrackedPreferencesMigration( | |
| 343 const std::set<std::string>& unprotected_pref_names, | |
| 344 const std::set<std::string>& protected_pref_names, | |
| 345 const base::Callback<void(const std::string& key)>& | |
| 346 unprotected_store_cleaner, | |
| 347 const base::Callback<void(const std::string& key)>& protected_store_cleaner, | |
| 348 const base::Callback<void(const base::Closure&)>& | |
| 349 register_on_successful_unprotected_store_write_callback, | |
| 350 const base::Callback<void(const base::Closure&)>& | |
| 351 register_on_successful_protected_store_write_callback, | |
| 352 scoped_ptr<PrefHashStore> unprotected_pref_hash_store, | |
| 353 scoped_ptr<PrefHashStore> protected_pref_hash_store, | |
| 354 scoped_ptr<HashStoreContents> legacy_pref_hash_store, | |
| 355 InterceptablePrefFilter* unprotected_pref_filter, | |
| 356 InterceptablePrefFilter* protected_pref_filter) { | |
| 357 scoped_refptr<TrackedPreferencesMigrator> prefs_migrator( | |
| 358 new TrackedPreferencesMigrator( | |
| 359 unprotected_pref_names, | |
| 360 protected_pref_names, | |
| 361 unprotected_store_cleaner, | |
| 362 protected_store_cleaner, | |
| 363 register_on_successful_unprotected_store_write_callback, | |
| 364 register_on_successful_protected_store_write_callback, | |
| 365 unprotected_pref_hash_store.Pass(), | |
| 366 protected_pref_hash_store.Pass(), | |
| 367 legacy_pref_hash_store.Pass(), | |
| 368 unprotected_pref_filter, | |
| 369 protected_pref_filter)); | |
| 370 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1227973003:
Componentize //chrome/browser/prefs/tracked. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master