Introduce a new framework for back-and-forth tracked/protected preferences migration.

chrome/browser/prefs/profile_pref_store_manager_unittest.cc

 // 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/profile_pref_store_manager.h"
 
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/json_pref_store.h"
 #include "base/prefs/persistent_pref_store.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/pref_service_factory.h"
 #include "base/prefs/pref_store.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/pref_hash_filter.h"
+#include "chrome/common/pref_names.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 class FirstEqualsPredicate {
  public:
   explicit FirstEqualsPredicate(const std::string& expected)
       : expected_(expected) {}
   bool operator()(const std::pair<std::string, base::Value*>& pair) {
@@ skipping 68 matching lines @@
       } else {
         profile_pref_registry_->RegisterDictionaryPref(
             it->name, user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
       }
     }
     profile_pref_registry_->RegisterStringPref(
         kUnprotectedPref,
         std::string(),
         user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 
+    // As in chrome_pref_service_factory.cc, kPreferencesResetTime needs to be
+    // declared as protected in order to be read from the proper store by the
+    // SegregatedPrefStore. Only declare it after configured prefs have been
+    // registered above for this test as kPreferenceResetTime is already
+    // registered in ProfilePrefStoreManager::RegisterProfilePrefs.
+    PrefHashFilter::TrackedPreferenceMetadata pref_reset_time_config =
+        {configuration_.rbegin()->reporting_id + 1, prefs::kPreferenceResetTime,
+         PrefHashFilter::ENFORCE_ON_LOAD,
+         PrefHashFilter::TRACKING_STRATEGY_ATOMIC};
+    configuration_.push_back(pref_reset_time_config);
+
     ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
     ReloadConfiguration();
   }
 
   void ReloadConfiguration() {
     manager_.reset(new ProfilePrefStoreManager(profile_dir_.path(),
                                                configuration_,
                                                kReportingIdCount,
                                                "seed",
                                                "device_id",
@@ skipping 291 matching lines @@
   LoadExistingPrefs();
 
   // If preference tracking is supported, kUnprotectedPref will have been
   // discarded because new values are not accepted without a valid super MAC.
   EXPECT_NE(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             pref_store_->GetValue(kUnprotectedPref, NULL));
   EXPECT_EQ(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             WasResetRecorded());
 }
 
-// This test does not directly verify that the values are moved from one pref
-// store to the other. segregated_pref_store_unittest.cc _does_ verify that
-// functionality.
-//
-// _This_ test verifies that preference values are correctly maintained when a
+// This test verifies that preference values are correctly maintained when a
 // preference's protection state changes from protected to unprotected.
 TEST_F(ProfilePrefStoreManagerTest, ProtectedToUnprotected) {
   InitializePrefs();
   DestroyPrefStore();
 
   // Unconfigure protection for kProtectedAtomic
   for (std::vector<PrefHashFilter::TrackedPreferenceMetadata>::iterator it =
            configuration_.begin();
        it != configuration_.end();
        ++it) {
     if (it->name == kProtectedAtomic) {
-      configuration_.erase(it);
+      it->enforcement_level = PrefHashFilter::NO_ENFORCEMENT;
       break;
     }
   }
   ReloadConfiguration();
 
   // Reset the hash stores and then try loading the prefs.
   ProfilePrefStoreManager::ResetAllPrefHashStores(&local_state_);
   LoadExistingPrefs();
 
   // Verify that the value was not reset.
   ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
   EXPECT_FALSE(WasResetRecorded());
 
   // Accessing the value of the previously protected pref didn't trigger its
   // move to the unprotected preferences file, though the loading of the pref
   // store should still have caused the MAC store to be recalculated.
   LoadExistingPrefs();
   ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
 
   // Trigger the logic that migrates it back to the unprotected preferences
   // file.
   pref_store_->SetValue(kProtectedAtomic, new base::StringValue(kGoodbyeWorld));
   LoadExistingPrefs();
   ExpectStringValueEquals(kProtectedAtomic, kGoodbyeWorld);
   EXPECT_FALSE(WasResetRecorded());
 }