blob: 382c924bfea130bf7ea6b07235ef2beb53254a7f [file] [log] [blame]
// 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.
#include "chrome/browser/prefs/tracked/tracked_preferences_migration.h"
#include "base/bind.h"
#include "base/callback.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/metrics/histogram.h"
#include "base/values.h"
#include "chrome/browser/prefs/interceptable_pref_filter.h"
#include "chrome/browser/prefs/pref_hash_store.h"
#include "chrome/browser/prefs/pref_hash_store_transaction.h"
#include "chrome/browser/prefs/tracked/dictionary_hash_store_contents.h"
#include "chrome/browser/prefs/tracked/hash_store_contents.h"
namespace {
class TrackedPreferencesMigrator
: public base::RefCounted<TrackedPreferencesMigrator> {
public:
TrackedPreferencesMigrator(
const std::set<std::string>& unprotected_pref_names,
const std::set<std::string>& protected_pref_names,
const base::Callback<void(const std::string& key)>&
unprotected_store_cleaner,
const base::Callback<void(const std::string& key)>&
protected_store_cleaner,
const base::Callback<void(const base::Closure&)>&
register_on_successful_unprotected_store_write_callback,
const base::Callback<void(const base::Closure&)>&
register_on_successful_protected_store_write_callback,
scoped_ptr<PrefHashStore> unprotected_pref_hash_store,
scoped_ptr<PrefHashStore> protected_pref_hash_store,
scoped_ptr<HashStoreContents> legacy_pref_hash_store,
InterceptablePrefFilter* unprotected_pref_filter,
InterceptablePrefFilter* protected_pref_filter);
private:
friend class base::RefCounted<TrackedPreferencesMigrator>;
enum PrefFilterID {
UNPROTECTED_PREF_FILTER,
PROTECTED_PREF_FILTER
};
~TrackedPreferencesMigrator();
// Stores the data coming in from the filter identified by |id| into this
// class and then calls MigrateIfReady();
void InterceptFilterOnLoad(
PrefFilterID id,
const InterceptablePrefFilter::FinalizeFilterOnLoadCallback&
finalize_filter_on_load,
scoped_ptr<base::DictionaryValue> prefs);
// Proceeds with migration if both |unprotected_prefs_| and |protected_prefs_|
// have been set.
void MigrateIfReady();
const std::set<std::string> unprotected_pref_names_;
const std::set<std::string> protected_pref_names_;
const base::Callback<void(const std::string& key)> unprotected_store_cleaner_;
const base::Callback<void(const std::string& key)> protected_store_cleaner_;
const base::Callback<void(const base::Closure&)>
register_on_successful_unprotected_store_write_callback_;
const base::Callback<void(const base::Closure&)>
register_on_successful_protected_store_write_callback_;
InterceptablePrefFilter::FinalizeFilterOnLoadCallback
finalize_unprotected_filter_on_load_;
InterceptablePrefFilter::FinalizeFilterOnLoadCallback
finalize_protected_filter_on_load_;
scoped_ptr<PrefHashStore> unprotected_pref_hash_store_;
scoped_ptr<PrefHashStore> protected_pref_hash_store_;
scoped_ptr<HashStoreContents> legacy_pref_hash_store_;
scoped_ptr<base::DictionaryValue> unprotected_prefs_;
scoped_ptr<base::DictionaryValue> protected_prefs_;
DISALLOW_COPY_AND_ASSIGN(TrackedPreferencesMigrator);
};
// Invokes |store_cleaner| for every |keys_to_clean|.
void CleanupPrefStore(
const base::Callback<void(const std::string& key)>& store_cleaner,
const std::set<std::string>& keys_to_clean) {
for (std::set<std::string>::const_iterator it = keys_to_clean.begin();
it != keys_to_clean.end(); ++it) {
store_cleaner.Run(*it);
}
}
// If |wait_for_commit_to_destination_store|: schedules (via
// |register_on_successful_destination_store_write_callback|) a cleanup of the
// |keys_to_clean| from the source pref store (through |source_store_cleaner|)
// once the destination pref store they were migrated to was successfully
// written to disk. Otherwise, executes the cleanup right away.
void ScheduleSourcePrefStoreCleanup(
const base::Callback<void(const base::Closure&)>&
register_on_successful_destination_store_write_callback,
const base::Callback<void(const std::string& key)>& source_store_cleaner,
const std::set<std::string>& keys_to_clean,
bool wait_for_commit_to_destination_store) {
DCHECK(!keys_to_clean.empty());
if (wait_for_commit_to_destination_store) {
register_on_successful_destination_store_write_callback.Run(
base::Bind(&CleanupPrefStore, source_store_cleaner, keys_to_clean));
} else {
CleanupPrefStore(source_store_cleaner, keys_to_clean);
}
}
// Removes hashes for |migrated_pref_names| from |origin_pref_store| using
// the configuration/implementation in |origin_pref_hash_store|.
void CleanupMigratedHashes(const std::set<std::string>& migrated_pref_names,
PrefHashStore* origin_pref_hash_store,
base::DictionaryValue* origin_pref_store) {
scoped_ptr<PrefHashStoreTransaction> transaction(
origin_pref_hash_store->BeginTransaction(scoped_ptr<HashStoreContents>(
new DictionaryHashStoreContents(origin_pref_store))));
for (std::set<std::string>::const_iterator it = migrated_pref_names.begin();
it != migrated_pref_names.end();
++it) {
transaction->ClearHash(*it);
}
}
// Copies the value of each pref in |pref_names| which is set in |old_store|,
// but not in |new_store| into |new_store|. Sets |old_store_needs_cleanup| to
// true if any old duplicates remain in |old_store| and sets |new_store_altered|
// to true if any value was copied to |new_store|.
void MigratePrefsFromOldToNewStore(const std::set<std::string>& pref_names,
base::DictionaryValue* old_store,
base::DictionaryValue* new_store,
PrefHashStore* new_hash_store,
HashStoreContents* legacy_hash_store,
bool* old_store_needs_cleanup,
bool* new_store_altered,
bool* used_legacy_pref_hashes) {
const base::DictionaryValue* old_hash_store_contents =
DictionaryHashStoreContents(old_store).GetContents();
const base::DictionaryValue* legacy_hash_store_contents =
legacy_hash_store->GetContents();
scoped_ptr<PrefHashStoreTransaction> new_hash_store_transaction(
new_hash_store->BeginTransaction(scoped_ptr<HashStoreContents>(
new DictionaryHashStoreContents(new_store))));
for (std::set<std::string>::const_iterator it = pref_names.begin();
it != pref_names.end();
++it) {
const std::string& pref_name = *it;
const base::Value* value_in_old_store = NULL;
// If the destination does not have a hash for this pref we will
// unconditionally attempt to move it.
bool destination_hash_missing =
!new_hash_store_transaction->HasHash(pref_name);
// If we migrate the value we will also attempt to migrate the hash.
bool migrated_value = false;
if (old_store->Get(pref_name, &value_in_old_store)) {
// Whether this value ends up being copied below or was left behind by a
// previous incomplete migration, it should be cleaned up.
*old_store_needs_cleanup = true;
if (!new_store->Get(pref_name, NULL)) {
// Copy the value from |old_store| to |new_store| rather than moving it
// to avoid data loss should |old_store| be flushed to disk without
// |new_store| having equivalently been successfully flushed to disk
// (e.g., on crash or in cases where |new_store| is read-only following
// a read error on startup).
new_store->Set(pref_name, value_in_old_store->DeepCopy());
migrated_value = true;
*new_store_altered = true;
}
}
if (destination_hash_missing || migrated_value) {
const base::Value* old_hash = NULL;
if (old_hash_store_contents)
old_hash_store_contents->Get(pref_name, &old_hash);
if (!old_hash && legacy_hash_store_contents) {
legacy_hash_store_contents->Get(pref_name, &old_hash);
if (old_hash)
*used_legacy_pref_hashes = true;
}
if (old_hash) {
new_hash_store_transaction->ImportHash(pref_name, old_hash);
*new_store_altered = true;
} else if (!destination_hash_missing) {
new_hash_store_transaction->ClearHash(pref_name);
*new_store_altered = true;
}
}
}
}
TrackedPreferencesMigrator::TrackedPreferencesMigrator(
const std::set<std::string>& unprotected_pref_names,
const std::set<std::string>& protected_pref_names,
const base::Callback<void(const std::string& key)>&
unprotected_store_cleaner,
const base::Callback<void(const std::string& key)>& protected_store_cleaner,
const base::Callback<void(const base::Closure&)>&
register_on_successful_unprotected_store_write_callback,
const base::Callback<void(const base::Closure&)>&
register_on_successful_protected_store_write_callback,
scoped_ptr<PrefHashStore> unprotected_pref_hash_store,
scoped_ptr<PrefHashStore> protected_pref_hash_store,
scoped_ptr<HashStoreContents> legacy_pref_hash_store,
InterceptablePrefFilter* unprotected_pref_filter,
InterceptablePrefFilter* protected_pref_filter)
: unprotected_pref_names_(unprotected_pref_names),
protected_pref_names_(protected_pref_names),
unprotected_store_cleaner_(unprotected_store_cleaner),
protected_store_cleaner_(protected_store_cleaner),
register_on_successful_unprotected_store_write_callback_(
register_on_successful_unprotected_store_write_callback),
register_on_successful_protected_store_write_callback_(
register_on_successful_protected_store_write_callback),
unprotected_pref_hash_store_(unprotected_pref_hash_store.Pass()),
protected_pref_hash_store_(protected_pref_hash_store.Pass()),
legacy_pref_hash_store_(legacy_pref_hash_store.Pass()) {
// The callbacks bound below will own this TrackedPreferencesMigrator by
// reference.
unprotected_pref_filter->InterceptNextFilterOnLoad(
base::Bind(&TrackedPreferencesMigrator::InterceptFilterOnLoad,
this,
UNPROTECTED_PREF_FILTER));
protected_pref_filter->InterceptNextFilterOnLoad(
base::Bind(&TrackedPreferencesMigrator::InterceptFilterOnLoad,
this,
PROTECTED_PREF_FILTER));
}
TrackedPreferencesMigrator::~TrackedPreferencesMigrator() {}
void TrackedPreferencesMigrator::InterceptFilterOnLoad(
PrefFilterID id,
const InterceptablePrefFilter::FinalizeFilterOnLoadCallback&
finalize_filter_on_load,
scoped_ptr<base::DictionaryValue> prefs) {
switch (id) {
case UNPROTECTED_PREF_FILTER:
finalize_unprotected_filter_on_load_ = finalize_filter_on_load;
unprotected_prefs_ = prefs.Pass();
break;
case PROTECTED_PREF_FILTER:
finalize_protected_filter_on_load_ = finalize_filter_on_load;
protected_prefs_ = prefs.Pass();
break;
}
MigrateIfReady();
}
void TrackedPreferencesMigrator::MigrateIfReady() {
// Wait for both stores to have been read before proceeding.
if (!protected_prefs_ || !unprotected_prefs_)
return;
bool used_legacy_pref_hashes = false;
bool protected_prefs_need_cleanup = false;
bool unprotected_prefs_altered = false;
MigratePrefsFromOldToNewStore(unprotected_pref_names_,
protected_prefs_.get(),
unprotected_prefs_.get(),
unprotected_pref_hash_store_.get(),
legacy_pref_hash_store_.get(),
&protected_prefs_need_cleanup,
&unprotected_prefs_altered,
&used_legacy_pref_hashes);
bool unprotected_prefs_need_cleanup = false;
bool protected_prefs_altered = false;
MigratePrefsFromOldToNewStore(protected_pref_names_,
unprotected_prefs_.get(),
protected_prefs_.get(),
protected_pref_hash_store_.get(),
legacy_pref_hash_store_.get(),
&unprotected_prefs_need_cleanup,
&protected_prefs_altered,
&used_legacy_pref_hashes);
UMA_HISTOGRAM_BOOLEAN("Settings.MigratedHashesFromLocalState",
used_legacy_pref_hashes);
if (!unprotected_prefs_altered && !protected_prefs_altered) {
// Clean up any MACs that might have been previously migrated from the
// various stores. It's safe to leave them behind for a little while as they
// will be ignored unless the corresponding value is _also_ present. The
// cleanup must be deferred until the MACs have been written to their target
// stores, and doing so in a subsequent launch is easier than within the
// same process.
CleanupMigratedHashes(unprotected_pref_names_,
protected_pref_hash_store_.get(),
protected_prefs_.get());
CleanupMigratedHashes(protected_pref_names_,
unprotected_pref_hash_store_.get(),
unprotected_prefs_.get());
legacy_pref_hash_store_->Reset();
}
// Hand the processed prefs back to their respective filters.
finalize_unprotected_filter_on_load_.Run(unprotected_prefs_.Pass(),
unprotected_prefs_altered);
finalize_protected_filter_on_load_.Run(protected_prefs_.Pass(),
protected_prefs_altered);
if (unprotected_prefs_need_cleanup) {
// Schedule a cleanup of the |protected_pref_names_| from the unprotected
// prefs once the protected prefs were successfully written to disk (or
// do it immediately if |!protected_prefs_altered|).
ScheduleSourcePrefStoreCleanup(
register_on_successful_protected_store_write_callback_,
unprotected_store_cleaner_,
protected_pref_names_,
protected_prefs_altered);
}
if (protected_prefs_need_cleanup) {
// Schedule a cleanup of the |unprotected_pref_names_| from the protected
// prefs once the unprotected prefs were successfully written to disk (or
// do it immediately if |!unprotected_prefs_altered|).
ScheduleSourcePrefStoreCleanup(
register_on_successful_unprotected_store_write_callback_,
protected_store_cleaner_,
unprotected_pref_names_,
unprotected_prefs_altered);
}
}
} // namespace
void SetupTrackedPreferencesMigration(
const std::set<std::string>& unprotected_pref_names,
const std::set<std::string>& protected_pref_names,
const base::Callback<void(const std::string& key)>&
unprotected_store_cleaner,
const base::Callback<void(const std::string& key)>& protected_store_cleaner,
const base::Callback<void(const base::Closure&)>&
register_on_successful_unprotected_store_write_callback,
const base::Callback<void(const base::Closure&)>&
register_on_successful_protected_store_write_callback,
scoped_ptr<PrefHashStore> unprotected_pref_hash_store,
scoped_ptr<PrefHashStore> protected_pref_hash_store,
scoped_ptr<HashStoreContents> legacy_pref_hash_store,
InterceptablePrefFilter* unprotected_pref_filter,
InterceptablePrefFilter* protected_pref_filter) {
scoped_refptr<TrackedPreferencesMigrator> prefs_migrator(
new TrackedPreferencesMigrator(
unprotected_pref_names,
protected_pref_names,
unprotected_store_cleaner,
protected_store_cleaner,
register_on_successful_unprotected_store_write_callback,
register_on_successful_protected_store_write_callback,
unprotected_pref_hash_store.Pass(),
protected_pref_hash_store.Pass(),
legacy_pref_hash_store.Pass(),
unprotected_pref_filter,
protected_pref_filter));
}