Remove unloaded profile hash store initialization,

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"
@@ skipping 72 matching lines @@
 const size_t kReportingIdCount = 3u;
 
 }  // namespace
 
 class ProfilePrefStoreManagerTest : public testing::Test {
  public:
   ProfilePrefStoreManagerTest()
       : configuration_(kConfiguration,
                        kConfiguration + arraysize(kConfiguration)),
         profile_pref_registry_(new user_prefs::PrefRegistrySyncable),
-        registry_verifier_(profile_pref_registry_) {}
+        registry_verifier_(profile_pref_registry_),
+        seed_("seed") {}
 
   virtual void SetUp() OVERRIDE {
     ProfilePrefStoreManager::RegisterPrefs(local_state_.registry());
     ProfilePrefStoreManager::RegisterProfilePrefs(profile_pref_registry_);
     for (const PrefHashFilter::TrackedPreferenceMetadata* it = kConfiguration;
          it != kConfiguration + arraysize(kConfiguration);
          ++it) {
       if (it->strategy == PrefHashFilter::TRACKING_STRATEGY_ATOMIC) {
         profile_pref_registry_->RegisterStringPref(
             it->name,
@@ skipping 21 matching lines @@
     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",
+                                               seed_,
                                                "device_id",
                                                &local_state_));
   }
 
   virtual void TearDown() OVERRIDE { DestroyPrefStore(); }
 
  protected:
   bool WasResetRecorded() {
     base::PrefServiceFactory pref_service_factory;
     pref_service_factory.set_user_prefs(pref_store_);
@@ skipping 99 matching lines @@
 
   base::MessageLoop main_message_loop_;
   std::vector<PrefHashFilter::TrackedPreferenceMetadata> configuration_;
   base::ScopedTempDir profile_dir_;
   TestingPrefServiceSimple local_state_;
   scoped_refptr<user_prefs::PrefRegistrySyncable> profile_pref_registry_;
   RegistryVerifier registry_verifier_;
   MockValidationDelegate mock_validation_delegate_;
   scoped_ptr<ProfilePrefStoreManager> manager_;
   scoped_refptr<PersistentPrefStore> pref_store_;
+
+  std::string seed_;
 };
 
 TEST_F(ProfilePrefStoreManagerTest, StoreValues) {
   InitializePrefs();
 
   LoadExistingPrefs();
 
   ExpectStringValueEquals(kTrackedAtomic, kFoobar);
   ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
   EXPECT_FALSE(WasResetRecorded());
@@ skipping 29 matching lines @@
   // will be discarded at load time, leaving this preference undefined.
   EXPECT_NE(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             pref_store_->GetValue(kProtectedAtomic, NULL));
   EXPECT_EQ(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             WasResetRecorded());
 
   ExpectValidationObserved(kTrackedAtomic);
   ExpectValidationObserved(kProtectedAtomic);
 }
 
-TEST_F(ProfilePrefStoreManagerTest, ResetPrefHashStore) {
-  InitializePrefs();
-
-  manager_->ResetPrefHashStore();
-
-  LoadExistingPrefs();
-
-  // kTrackedAtomic is loaded as it appears on disk.
-  ExpectStringValueEquals(kTrackedAtomic, kFoobar);
-  // If preference tracking is supported, kProtectedAtomic will be undefined
-  // because the value was discarded due to loss of the hash store contents.
-  EXPECT_NE(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
-            pref_store_->GetValue(kProtectedAtomic, NULL));
-  EXPECT_EQ(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
-            WasResetRecorded());
-
-  ExpectValidationObserved(kTrackedAtomic);
-  ExpectValidationObserved(kProtectedAtomic);
-}
-
-TEST_F(ProfilePrefStoreManagerTest, ResetAllPrefHashStores) {
-  InitializePrefs();
-
-  ProfilePrefStoreManager::ResetAllPrefHashStores(&local_state_);
-
-  LoadExistingPrefs();
-
-  // kTrackedAtomic is loaded as it appears on disk.
-  ExpectStringValueEquals(kTrackedAtomic, kFoobar);
-  // If preference tracking is supported, kProtectedAtomic will be undefined
-  // because the value was discarded due to loss of the hash store contents.
-  EXPECT_NE(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
-            pref_store_->GetValue(kProtectedAtomic, NULL));
-  EXPECT_EQ(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
-            WasResetRecorded());
-
-  ExpectValidationObserved(kTrackedAtomic);
-  ExpectValidationObserved(kProtectedAtomic);
-}
-
 TEST_F(ProfilePrefStoreManagerTest, MigrateFromOneFile) {
   InitializeDeprecatedCombinedProfilePrefStore();
 
   LoadExistingPrefs();
 
   ExpectStringValueEquals(kTrackedAtomic, kFoobar);
   ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
   EXPECT_FALSE(WasResetRecorded());
 }
 
-TEST_F(ProfilePrefStoreManagerTest, UpdateProfileHashStoreIfRequired) {
-  scoped_refptr<JsonPrefStore> legacy_prefs(
-      new JsonPrefStore(ProfilePrefStoreManager::GetPrefFilePathFromProfilePath(
-                            profile_dir_.path()),
-                        main_message_loop_.message_loop_proxy(),
-                        scoped_ptr<PrefFilter>()));
-  legacy_prefs->SetValue(kTrackedAtomic, new base::StringValue(kFoobar));
-  legacy_prefs->SetValue(kProtectedAtomic, new base::StringValue(kHelloWorld));
-  legacy_prefs = NULL;
-  base::RunLoop().RunUntilIdle();
-
-  // This is a no-op if !kPlatformSupportsPreferenceTracking.
-  manager_->UpdateProfileHashStoreIfRequired(
-      main_message_loop_.message_loop_proxy());
-  base::RunLoop().RunUntilIdle();
-
-  // At the moment, UpdateProfileHashStoreIfRequired will accept existing
-  // values.
-  LoadExistingPrefs();
-
-  // These expectations hold whether or not tracking is supported.
-  ExpectStringValueEquals(kTrackedAtomic, kFoobar);
-  ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
-  EXPECT_FALSE(WasResetRecorded());
-}
-
 TEST_F(ProfilePrefStoreManagerTest, InitializePrefsFromMasterPrefs) {
   base::DictionaryValue master_prefs;
   master_prefs.Set(kTrackedAtomic, new base::StringValue(kFoobar));
   master_prefs.Set(kProtectedAtomic, new base::StringValue(kHelloWorld));
   EXPECT_TRUE(manager_->InitializePrefsFromMasterPrefs(master_prefs));
 
   LoadExistingPrefs();
 
   // Verify that InitializePrefsFromMasterPrefs correctly applied the MACs
   // necessary to authenticate these values.
@@ skipping 24 matching lines @@
   PrefHashFilter::TrackedPreferenceMetadata new_protected = {
       kExtraReportingId, kUnprotectedPref, PrefHashFilter::ENFORCE_ON_LOAD,
       PrefHashFilter::TRACKING_STRATEGY_ATOMIC};
   configuration_.push_back(new_protected);
   ReloadConfiguration();
 
   // And try loading with the new configuration.
   LoadExistingPrefs();
 
   // Since there was a valid super MAC we were able to extend the existing trust
-  // to the newly proteted preference.
+  // to the newly protected preference.
   ExpectStringValueEquals(kUnprotectedPref, kBarfoo);
   EXPECT_FALSE(WasResetRecorded());
 
   // Ensure everything is written out to disk.
   DestroyPrefStore();
 
   // It's protected now, so (if the platform supports it) any tampering should
   // lead to a reset.
   ReplaceStringInPrefs(kBarfoo, kFoobar);
   LoadExistingPrefs();
   EXPECT_NE(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             pref_store_->GetValue(kUnprotectedPref, NULL));
   EXPECT_EQ(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             WasResetRecorded());
 }
 
 TEST_F(ProfilePrefStoreManagerTest, UnprotectedToProtectedWithoutTrust) {
   InitializePrefs();
 
   ExpectValidationObserved(kTrackedAtomic);
   ExpectValidationObserved(kProtectedAtomic);
 
   // Now update the configuration to protect it.
   PrefHashFilter::TrackedPreferenceMetadata new_protected = {
       kExtraReportingId, kUnprotectedPref, PrefHashFilter::ENFORCE_ON_LOAD,
       PrefHashFilter::TRACKING_STRATEGY_ATOMIC};
   configuration_.push_back(new_protected);
+  seed_ = "new-seed-to-break-trust";
   ReloadConfiguration();
-  ProfilePrefStoreManager::ResetAllPrefHashStores(&local_state_);
 
   // And try loading with the new configuration.
   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());
@@ skipping 12 matching lines @@
   // Unconfigure protection for kProtectedAtomic
   for (std::vector<PrefHashFilter::TrackedPreferenceMetadata>::iterator it =
            configuration_.begin();
        it != configuration_.end();
        ++it) {
     if (it->name == kProtectedAtomic) {
       it->enforcement_level = PrefHashFilter::NO_ENFORCEMENT;
       break;
     }
   }
+
+  seed_ = "new-seed-to-break-trust";
   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());
 }