Separate storage for protected preferences into Protected Preferences file.

chrome/browser/prefs/pref_hash_filter_unittest.cc

 // Copyright 2013 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/pref_hash_filter.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_forward.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/prefs/testing_pref_store.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/pref_hash_store.h"
 #include "chrome/browser/prefs/pref_hash_store_transaction.h"
 #include "chrome/common/pref_names.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const char kAtomicPref[] = "atomic_pref";
 const char kAtomicPref2[] = "atomic_pref2";
@@ skipping 31 matching lines @@
 
 }  // namespace
 
 // A PrefHashStore that allows simulation of CheckValue results and captures
 // checked and stored values.
 class MockPrefHashStore : public PrefHashStore {
  public:
   typedef std::pair<const void*, PrefHashFilter::PrefTrackingStrategy>
       ValuePtrStrategyPair;
 
-  MockPrefHashStore() : transactions_expected_(1),
-                        transactions_performed_(0),
+  MockPrefHashStore() : transactions_performed_(0),
                         transaction_active_(false) {}
 
   virtual ~MockPrefHashStore() {
-    EXPECT_EQ(transactions_expected_, transactions_performed_);
     EXPECT_FALSE(transaction_active_);
   }
 
   // Set the result that will be returned when |path| is passed to
   // |CheckValue/CheckSplitValue|.
   void SetCheckResult(const std::string& path,
                       PrefHashStoreTransaction::ValueState result);
 
   // Set the invalid_keys that will be returned when |path| is passed to
   // |CheckSplitValue|. SetCheckResult should already have been called for
   // |path| with |result == CHANGED| for this to make any sense.
   void SetInvalidKeysResult(
       const std::string& path,
       const std::vector<std::string>& invalid_keys_result);
 
-  void set_transactions_expected(size_t transactions_expected) {
-    transactions_expected_ = transactions_expected;
-  }
+  // Returns the number of transactions that were performed.
+  size_t transactions_performed() { return transactions_performed_; }
 
   // Returns the number of paths checked.
   size_t checked_paths_count() const {
     return checked_values_.size();
   }
 
   // Returns the number of paths stored.
   size_t stored_paths_count() const {
     return stored_values_.size();
   }
@@ skipping 174 matching lines @@
                                   PrefHashFilter::TRACKING_STRATEGY_SPLIT);
 }
 
 void MockPrefHashStore::MockPrefHashStoreTransaction::StoreSplitHash(
     const std::string& path,
     const base::DictionaryValue* new_value) {
   outer_->RecordStoreHash(path, new_value,
                           PrefHashFilter::TRACKING_STRATEGY_SPLIT);
 }
 
-// Creates a PrefHashFilter that uses a MockPrefHashStore. The
-// MockPrefHashStore (owned by the PrefHashFilter) is returned in
-// |mock_pref_hash_store|.
-scoped_ptr<PrefHashFilter> CreatePrefHashFilter(
-    PrefHashFilter::EnforcementLevel max_enforcement_level,
-    MockPrefHashStore** mock_pref_hash_store) {
-  scoped_ptr<MockPrefHashStore> temp_mock_pref_hash_store(
-      new MockPrefHashStore);
-  if (mock_pref_hash_store)
-    *mock_pref_hash_store = temp_mock_pref_hash_store.get();
+std::vector<PrefHashFilter::TrackedPreferenceMetadata> GetConfiguration(
+    PrefHashFilter::EnforcementLevel max_enforcement_level) {
   std::vector<PrefHashFilter::TrackedPreferenceMetadata> configuration(
       kTestTrackedPrefs, kTestTrackedPrefs + arraysize(kTestTrackedPrefs));
   for (std::vector<PrefHashFilter::TrackedPreferenceMetadata>::iterator it =
            configuration.begin();
        it != configuration.end();
        ++it) {
     if (it->enforcement_level > max_enforcement_level)
       it->enforcement_level = max_enforcement_level;
   }
-  return scoped_ptr<PrefHashFilter>(
-      new PrefHashFilter(temp_mock_pref_hash_store.PassAs<PrefHashStore>(),
-                         configuration,
-                         arraysize(kTestTrackedPrefs)));
+  return configuration;
 }
 
 class PrefHashFilterTest
     : public testing::TestWithParam<PrefHashFilter::EnforcementLevel> {
  public:
   PrefHashFilterTest() : mock_pref_hash_store_(NULL) {}
 
   virtual void SetUp() OVERRIDE {
     // Construct a PrefHashFilter and MockPrefHashStore for the test.
-    pref_hash_filter_ =
-        CreatePrefHashFilter(GetParam(), &mock_pref_hash_store_);
+    InitializePrefHashFilter(GetConfiguration(GetParam()));
   }
 
  protected:
+  // Creates a PrefHashFilter that uses a MockPrefHashStore. The
+  // MockPrefHashStore (owned by the PrefHashFilter) is returned in
+  // |mock_pref_hash_store|.

[gab, 2014/04/01 18:55:06]

This comment is wrong, what about:

// Resets |pref_hash_filter_| with a PrefHashFilter that uses a
MockPrefHashStore. The raw pointer to the MockPrefHashStore (owned by the
PrefHashFilter) is stored in |mock_pref_hash_store_| for testing.

+  void InitializePrefHashFilter(const std::vector<
+      PrefHashFilter::TrackedPreferenceMetadata>& configuration) {
+    scoped_ptr<MockPrefHashStore> temp_mock_pref_hash_store(
+        new MockPrefHashStore);
+    mock_pref_hash_store_ = temp_mock_pref_hash_store.get();
+    pref_hash_filter_.reset(
+        new PrefHashFilter(temp_mock_pref_hash_store.PassAs<PrefHashStore>(),
+                           configuration,
+                           arraysize(kTestTrackedPrefs)));
+  }
+
   bool RecordedReset() {
     return pref_store_contents_.Get(prefs::kPreferenceResetTime, NULL);
   }
 
   MockPrefHashStore* mock_pref_hash_store_;
   base::DictionaryValue pref_store_contents_;
   scoped_ptr<PrefHashFilter> pref_hash_filter_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefHashFilterTest);
 };
 
 TEST_P(PrefHashFilterTest, EmptyAndUnchanged) {
   pref_hash_filter_->FilterOnLoad(&pref_store_contents_);
   // All paths checked.
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
   // No paths stored, since they all return |UNCHANGED|.
   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
   // Since there was nothing in |pref_store_contents_| the checked value should
   // have been NULL for all tracked preferences.
   for (size_t i = 0; i < arraysize(kTestTrackedPrefs); ++i) {
     ASSERT_EQ(NULL, mock_pref_hash_store_->checked_value(
                         kTestTrackedPrefs[i].name).first);
   }
+  ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
   ASSERT_FALSE(RecordedReset());
 }
 
 TEST_P(PrefHashFilterTest, FilterTrackedPrefUpdate) {
   base::DictionaryValue root_dict;
   // Ownership of |string_value| is transfered to |root_dict|.
   base::Value* string_value = base::Value::CreateStringValue("string value");
   root_dict.Set(kAtomicPref, string_value);
 
   // No path should be stored on FilterUpdate.
   pref_hash_filter_->FilterUpdate(kAtomicPref);
   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 
   // One path should be stored on FilterSerializeData.
   pref_hash_filter_->FilterSerializeData(&root_dict);
   ASSERT_EQ(1u, mock_pref_hash_store_->stored_paths_count());
   MockPrefHashStore::ValuePtrStrategyPair stored_value =
       mock_pref_hash_store_->stored_value(kAtomicPref);
   ASSERT_EQ(string_value, stored_value.first);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC, stored_value.second);
 
+  ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
   ASSERT_FALSE(RecordedReset());
 }
 
 TEST_P(PrefHashFilterTest, FilterSplitPrefUpdate) {
   base::DictionaryValue root_dict;
   // Ownership of |dict_value| is transfered to |root_dict|.
   base::DictionaryValue* dict_value = new base::DictionaryValue;
   dict_value->SetString("a", "foo");
   dict_value->SetInteger("b", 1234);
   root_dict.Set(kSplitPref, dict_value);
 
   // No path should be stored on FilterUpdate.
   pref_hash_filter_->FilterUpdate(kSplitPref);
   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 
   // One path should be stored on FilterSerializeData.
   pref_hash_filter_->FilterSerializeData(&root_dict);
   ASSERT_EQ(1u, mock_pref_hash_store_->stored_paths_count());
   MockPrefHashStore::ValuePtrStrategyPair stored_value =
        mock_pref_hash_store_->stored_value(kSplitPref);
   ASSERT_EQ(dict_value, stored_value.first);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, stored_value.second);
 
+  ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
   ASSERT_FALSE(RecordedReset());
 }
 
 TEST_P(PrefHashFilterTest, FilterUntrackedPrefUpdate) {
-  // No transaction should even be started on FilterSerializeData() if there are
-  // no updates to perform.
-  mock_pref_hash_store_->set_transactions_expected(0);
-
   base::DictionaryValue root_dict;
   root_dict.Set("untracked", base::Value::CreateStringValue("some value"));
   pref_hash_filter_->FilterUpdate("untracked");
 
   // No paths should be stored on FilterUpdate.
   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 
   // Nor on FilterSerializeData.
   pref_hash_filter_->FilterSerializeData(&root_dict);
   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
+
+  // No transaction should even be started on FilterSerializeData() if there are
+  // no updates to perform.
+  ASSERT_EQ(0u, mock_pref_hash_store_->transactions_performed());
 }
 
 TEST_P(PrefHashFilterTest, MultiplePrefsFilterSerializeData) {
   base::DictionaryValue root_dict;
   // Ownership of the following values is transfered to |root_dict|.
   base::Value* int_value1 = base::Value::CreateIntegerValue(1);
   base::Value* int_value2 = base::Value::CreateIntegerValue(2);
   base::Value* int_value3 = base::Value::CreateIntegerValue(3);
   base::Value* int_value4 = base::Value::CreateIntegerValue(4);
   base::DictionaryValue* dict_value = new base::DictionaryValue;
@@ skipping 17 matching lines @@
 
   // On FilterSerializeData, only kAtomicPref, kAtomicPref3, and kSplitPref
   // should get a new hash.
   pref_hash_filter_->FilterSerializeData(&root_dict);
   ASSERT_EQ(3u, mock_pref_hash_store_->stored_paths_count());
   MockPrefHashStore::ValuePtrStrategyPair stored_value_atomic1 =
       mock_pref_hash_store_->stored_value(kAtomicPref);
   ASSERT_EQ(int_value1, stored_value_atomic1.first);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
             stored_value_atomic1.second);
+  ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 
   MockPrefHashStore::ValuePtrStrategyPair stored_value_atomic3 =
       mock_pref_hash_store_->stored_value(kAtomicPref3);
   ASSERT_EQ(int_value5, stored_value_atomic3.first);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
             stored_value_atomic3.second);
 
   MockPrefHashStore::ValuePtrStrategyPair stored_value_split =
        mock_pref_hash_store_->stored_value(kSplitPref);
   ASSERT_EQ(dict_value, stored_value_split.first);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, stored_value_split.second);
 }
 
 TEST_P(PrefHashFilterTest, EmptyAndUnknown) {
   ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL));
   ASSERT_FALSE(pref_store_contents_.Get(kSplitPref, NULL));
   // NULL values are always trusted by the PrefHashStore.
   mock_pref_hash_store_->SetCheckResult(
       kAtomicPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE);
   mock_pref_hash_store_->SetCheckResult(
       kSplitPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE);
   pref_hash_filter_->FilterOnLoad(&pref_store_contents_);
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
   ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
+  ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 
   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
        mock_pref_hash_store_->stored_value(kAtomicPref);
   ASSERT_EQ(NULL, stored_atomic_value.first);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
             stored_atomic_value.second);
 
   MockPrefHashStore::ValuePtrStrategyPair stored_split_value =
        mock_pref_hash_store_->stored_value(kSplitPref);
   ASSERT_EQ(NULL, stored_split_value.first);
@@ skipping 15 matching lines @@
   ASSERT_TRUE(pref_store_contents_.Get(kSplitPref, NULL));
 
   mock_pref_hash_store_->SetCheckResult(
       kAtomicPref, PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE);
   mock_pref_hash_store_->SetCheckResult(
       kSplitPref, PrefHashStoreTransaction::UNTRUSTED_UNKNOWN_VALUE);
   pref_hash_filter_->FilterOnLoad(&pref_store_contents_);
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
   ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
+  ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 
   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
        mock_pref_hash_store_->stored_value(kAtomicPref);
   MockPrefHashStore::ValuePtrStrategyPair stored_split_value =
        mock_pref_hash_store_->stored_value(kSplitPref);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
             stored_atomic_value.second);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT,
             stored_split_value.second);
   if (GetParam() == PrefHashFilter::ENFORCE_ON_LOAD) {
@@ skipping 37 matching lines @@
   ASSERT_TRUE(pref_store_contents_.Get(kSplitPref, NULL));
 
   mock_pref_hash_store_->SetCheckResult(
       kAtomicPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE);
   mock_pref_hash_store_->SetCheckResult(
       kSplitPref, PrefHashStoreTransaction::TRUSTED_UNKNOWN_VALUE);
   pref_hash_filter_->FilterOnLoad(&pref_store_contents_);
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
   ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
+  ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 
   // Seeding is always allowed for trusted unknown values.
   const base::Value* atomic_value_in_store;
   ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, &atomic_value_in_store));
   ASSERT_EQ(string_value, atomic_value_in_store);
   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
        mock_pref_hash_store_->stored_value(kAtomicPref);
   ASSERT_EQ(string_value, stored_atomic_value.first);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
             stored_atomic_value.second);
@@ skipping 30 matching lines @@
 
   std::vector<std::string> mock_invalid_keys;
   mock_invalid_keys.push_back("a");
   mock_invalid_keys.push_back("c");
   mock_pref_hash_store_->SetInvalidKeysResult(kSplitPref, mock_invalid_keys);
 
   pref_hash_filter_->FilterOnLoad(&pref_store_contents_);
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
   ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
+  ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 
   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
        mock_pref_hash_store_->stored_value(kAtomicPref);
   MockPrefHashStore::ValuePtrStrategyPair stored_split_value =
        mock_pref_hash_store_->stored_value(kSplitPref);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
             stored_atomic_value.second);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT,
             stored_split_value.second);
   if (GetParam() == PrefHashFilter::ENFORCE_ON_LOAD) {
@@ skipping 40 matching lines @@
   ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL));
   ASSERT_FALSE(pref_store_contents_.Get(kSplitPref, NULL));
   mock_pref_hash_store_->SetCheckResult(kAtomicPref,
                                         PrefHashStoreTransaction::CLEARED);
   mock_pref_hash_store_->SetCheckResult(kSplitPref,
                                         PrefHashStoreTransaction::CLEARED);
   pref_hash_filter_->FilterOnLoad(&pref_store_contents_);
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
   ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
+  ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 
   // Regardless of the enforcement level, the only thing that should be done is
   // to restore the hash for NULL. The value itself should still be NULL.
   ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL));
   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
        mock_pref_hash_store_->stored_value(kAtomicPref);
   ASSERT_EQ(NULL, stored_atomic_value.first);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
             stored_atomic_value.second);
 
@@ skipping 14 matching lines @@
   pref_store_contents_.Set(kAtomicPref, list_value);
 
   ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, NULL));
 
   mock_pref_hash_store_->SetCheckResult(kAtomicPref,
                                         PrefHashStoreTransaction::WEAK_LEGACY);
   pref_hash_filter_->FilterOnLoad(&pref_store_contents_);
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
   ASSERT_EQ(1u, mock_pref_hash_store_->stored_paths_count());
+  ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 
   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
        mock_pref_hash_store_->stored_value(kAtomicPref);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
             stored_atomic_value.second);
   if (GetParam() == PrefHashFilter::ENFORCE_ON_LOAD) {
     // Ensure the pref was cleared and the hash for NULL was restored if the
     // current enforcement level prevents migration.
     ASSERT_FALSE(pref_store_contents_.Get(kAtomicPref, NULL));
     ASSERT_EQ(NULL, stored_atomic_value.first);
@@ skipping 24 matching lines @@
   ASSERT_TRUE(pref_store_contents_.Get(kAtomicPref, NULL));
   ASSERT_TRUE(pref_store_contents_.Get(kSplitPref, NULL));
 
   mock_pref_hash_store_->SetCheckResult(
       kAtomicPref, PrefHashStoreTransaction::SECURE_LEGACY);
   mock_pref_hash_store_->SetCheckResult(
       kSplitPref, PrefHashStoreTransaction::SECURE_LEGACY);
   pref_hash_filter_->FilterOnLoad(&pref_store_contents_);
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
+  ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 
   // Ensure that both the atomic and split hashes were restored.
   ASSERT_EQ(2u, mock_pref_hash_store_->stored_paths_count());
 
   // In all cases, the values should have remained intact and the hashes should
   // have been updated to match them.
 
   MockPrefHashStore::ValuePtrStrategyPair stored_atomic_value =
        mock_pref_hash_store_->stored_value(kAtomicPref);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
@@ skipping 39 matching lines @@
   mock_pref_hash_store_->SetCheckResult(kReportOnlyPref,
                                         PrefHashStoreTransaction::CHANGED);
   mock_pref_hash_store_->SetCheckResult(kReportOnlySplitPref,
                                         PrefHashStoreTransaction::CHANGED);
   pref_hash_filter_->FilterOnLoad(&pref_store_contents_);
   // All prefs should be checked and a new hash should be stored for each tested
   // pref.
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
   ASSERT_EQ(4u, mock_pref_hash_store_->stored_paths_count());
+  ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
 
   // No matter what the enforcement level is, the report only pref should never
   // be reset.
   ASSERT_TRUE(pref_store_contents_.Get(kReportOnlyPref, NULL));
   ASSERT_TRUE(pref_store_contents_.Get(kReportOnlySplitPref, NULL));
   ASSERT_EQ(report_only_val,
             mock_pref_hash_store_->stored_value(kReportOnlyPref).first);
   ASSERT_EQ(report_only_split_val,
             mock_pref_hash_store_->stored_value(kReportOnlySplitPref).first);
 
@@ skipping 14 matching lines @@
     ASSERT_EQ(int_value1,
               mock_pref_hash_store_->stored_value(kAtomicPref).first);
     ASSERT_EQ(int_value2, value_in_store2);
     ASSERT_EQ(int_value2,
               mock_pref_hash_store_->stored_value(kAtomicPref2).first);
 
     ASSERT_FALSE(RecordedReset());
   }
 }
 
+TEST_P(PrefHashFilterTest, MigrateValuesTest) {
+  // Migration configuration should only contain the protected preferences.
+  std::vector<PrefHashFilter::TrackedPreferenceMetadata> configuration =
+      GetConfiguration(GetParam());
+  std::vector<PrefHashFilter::TrackedPreferenceMetadata>
+      migration_configuration;
+
+  for (std::vector<PrefHashFilter::TrackedPreferenceMetadata>::iterator it =
+           configuration.begin();
+       it != configuration.end();
+       ++it) {
+    if (it->enforcement_level >= PrefHashFilter::ENFORCE_ON_LOAD)
+      migration_configuration.push_back(*it);
+  }
+
+  // Discards the default created pref_hash_filter_.
+  InitializePrefHashFilter(migration_configuration);
+
+  scoped_refptr<TestingPrefStore> source(new TestingPrefStore);
+  scoped_refptr<TestingPrefStore> destination(new TestingPrefStore);
+
+  source->SetString(kAtomicPref, "foobar");
+  source->SetString(kAtomicPref2, "foobar2");
+  destination->SetString(kAtomicPref2, "foobar2 preexisting");
+  destination->SetString(kAtomicPref3, "foobar3");
+  source->SetString(kReportOnlyPref, "helloworld");
+
+  mock_pref_hash_store_->SetCheckResult(kAtomicPref,
+                                        PrefHashStoreTransaction::UNCHANGED);
+  mock_pref_hash_store_->SetCheckResult(kAtomicPref2,
+                                        PrefHashStoreTransaction::UNCHANGED);
+  mock_pref_hash_store_->SetCheckResult(kAtomicPref3,
+                                        PrefHashStoreTransaction::UNCHANGED);

[gab, 2014/04/01 18:55:06]

To have better test coverage, one of these would be CHANGED and expected to be
reset below.

+  mock_pref_hash_store_->SetCheckResult(kReportOnlyPref,
+                                        PrefHashStoreTransaction::UNCHANGED);
+
+  pref_hash_filter_->MigrateValues(source, destination);
+  ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
+
+  if (GetParam() == PrefHashFilter::ENFORCE_ON_LOAD) {
+    std::string value;
+
+    ASSERT_FALSE(source->GetValue(kAtomicPref, NULL));
+    ASSERT_FALSE(source->GetValue(kAtomicPref2, NULL));
+    ASSERT_FALSE(source->GetValue(kAtomicPref3, NULL));
+    ASSERT_TRUE(source->GetString(kReportOnlyPref, &value));
+    ASSERT_EQ("helloworld", value);
+
+    ASSERT_TRUE(destination->GetString(kAtomicPref, &value));
+    ASSERT_EQ("foobar", value);
+    ASSERT_TRUE(destination->GetString(kAtomicPref2, &value));
+    ASSERT_EQ("foobar2 preexisting", value);
+    ASSERT_TRUE(destination->GetString(kAtomicPref3, &value));
+    ASSERT_EQ("foobar3", value);
+    ASSERT_FALSE(destination->GetValue(kReportOnlyPref, NULL));
+  } else {
+    std::string value;
+
+    ASSERT_TRUE(source->GetString(kAtomicPref, &value));
+    ASSERT_EQ("foobar", value);
+    ASSERT_TRUE(source->GetString(kAtomicPref2, &value));
+    ASSERT_EQ("foobar2", value);
+    ASSERT_FALSE(source->GetString(kAtomicPref3, &value));
+    ASSERT_TRUE(source->GetString(kReportOnlyPref, &value));
+    ASSERT_EQ("helloworld", value);
+
+    ASSERT_FALSE(destination->GetValue(kAtomicPref, NULL));
+    ASSERT_TRUE(destination->GetString(kAtomicPref2, &value));
+    ASSERT_EQ("foobar2 preexisting", value);
+    ASSERT_TRUE(destination->GetValue(kAtomicPref3, NULL));

[gab, 2014/04/01 18:55:06]

Why not check the value of kAtomicPref3 in this case?

+    ASSERT_FALSE(destination->GetValue(kReportOnlyPref, NULL));
+  }
+}
+
 INSTANTIATE_TEST_CASE_P(
     PrefHashFilterTestInstance, PrefHashFilterTest,
     testing::Values(PrefHashFilter::NO_ENFORCEMENT,
                     PrefHashFilter::ENFORCE_ON_LOAD));