Clean up old legacy preference migration logic.

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 <stddef.h>
 
 #include <memory>
 #include <vector>
@@ skipping 11 matching lines @@
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/json_pref_store.h"
 #include "components/prefs/persistent_pref_store.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/pref_service_factory.h"
 #include "components/prefs/pref_store.h"
 #include "components/prefs/testing_pref_service.h"
 #include "components/user_prefs/tracked/mock_validation_delegate.h"
 #include "components/user_prefs/tracked/pref_hash_filter.h"
 #include "components/user_prefs/tracked/pref_names.h"
-#include "components/user_prefs/tracked/pref_service_hash_store_contents.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) {
     return pair.first == expected_;
@@ skipping 49 matching lines @@
  public:
   ProfilePrefStoreManagerTest()
       : configuration_(kConfiguration,
                        kConfiguration + arraysize(kConfiguration)),
         profile_pref_registry_(new user_prefs::PrefRegistrySyncable),
         registry_verifier_(profile_pref_registry_.get()),
         seed_("seed"),
         reset_recorded_(false) {}
 
   void SetUp() override {
-    ProfilePrefStoreManager::RegisterPrefs(local_state_.registry());
     ProfilePrefStoreManager::RegisterProfilePrefs(profile_pref_registry_.get());
     for (const PrefHashFilter::TrackedPreferenceMetadata* it = kConfiguration;
          it != kConfiguration + arraysize(kConfiguration);
          ++it) {
       if (it->strategy == PrefHashFilter::TRACKING_STRATEGY_ATOMIC) {
         profile_pref_registry_->RegisterStringPref(it->name, std::string());
       } else {
         profile_pref_registry_->RegisterDictionaryPref(it->name);
       }
     }
@@ skipping 78 matching lines @@
       base::RunLoop().RunUntilIdle();
 
       pref_store_->RemoveObserver(&registry_verifier_);
       pref_store_ = NULL;
       // Nothing should have to happen on the background threads, but just in
       // case...
       base::RunLoop().RunUntilIdle();
     }
   }
 
-  void InitializeDeprecatedCombinedProfilePrefStore() {
-    scoped_refptr<PersistentPrefStore> pref_store =
-        manager_->CreateDeprecatedCombinedProfilePrefStore(
-            main_message_loop_.task_runner());
-    InitializePrefStore(pref_store.get());
-    pref_store = NULL;
-    base::RunLoop().RunUntilIdle();
-  }
-
   void InitializePrefStore(PersistentPrefStore* pref_store) {
     pref_store->AddObserver(&registry_verifier_);
     PersistentPrefStore::PrefReadError error = pref_store->ReadPrefs();
     EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NO_FILE, error);
     pref_store->SetValue(kTrackedAtomic,
                          base::WrapUnique(new base::StringValue(kFoobar)),
                          WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
     pref_store->SetValue(kProtectedAtomic,
                          base::WrapUnique(new base::StringValue(kHelloWorld)),
                          WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
@@ skipping 105 matching lines @@
   // will be discarded at load time, leaving this preference undefined.
   EXPECT_NE(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             pref_store_->GetValue(kProtectedAtomic, NULL));
   VerifyResetRecorded(
       ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking);
 
   ExpectValidationObserved(kTrackedAtomic);
   ExpectValidationObserved(kProtectedAtomic);
 }
 
-TEST_F(ProfilePrefStoreManagerTest, MigrateFromOneFile) {
-  InitializeDeprecatedCombinedProfilePrefStore();
-
-  // The deprecated model stores hashes in local state (on supported
-  // platforms)..
-  ASSERT_EQ(
-      ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
-      local_state_.GetUserPrefValue(
-          PrefServiceHashStoreContents::kProfilePreferenceHashes) != NULL);
-
-  LoadExistingPrefs();
-
-  // After a first migration, the hashes were copied to the two user preference
-  // files but were not cleaned.
-  ASSERT_EQ(
-      ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
-      local_state_.GetUserPrefValue(
-          PrefServiceHashStoreContents::kProfilePreferenceHashes) != NULL);
-
-  ExpectStringValueEquals(kTrackedAtomic, kFoobar);
-  ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
-  VerifyResetRecorded(false);
-
-  LoadExistingPrefs();
-
-  // In a subsequent launch, the local state hash store should be reset.
-  ASSERT_FALSE(local_state_.GetUserPrefValue(
-      PrefServiceHashStoreContents::kProfilePreferenceHashes));
-
-  ExpectStringValueEquals(kTrackedAtomic, kFoobar);
-  ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
-  VerifyResetRecorded(false);
-}
-
-TEST_F(ProfilePrefStoreManagerTest, MigrateWithTampering) {
-  InitializeDeprecatedCombinedProfilePrefStore();
-
-  ReplaceStringInPrefs(kFoobar, kBarfoo);
-  ReplaceStringInPrefs(kHelloWorld, kGoodbyeWorld);
-
-  // The deprecated model stores hashes in local state (on supported
-  // platforms)..
-  ASSERT_EQ(
-      ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
-      local_state_.GetUserPrefValue(
-          PrefServiceHashStoreContents::kProfilePreferenceHashes) != NULL);
-
-  LoadExistingPrefs();
-
-  // After a first migration, the hashes were copied to the two user preference
-  // files but were not cleaned.
-  ASSERT_EQ(
-      ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
-      local_state_.GetUserPrefValue(
-          PrefServiceHashStoreContents::kProfilePreferenceHashes) != NULL);
-
-  // kTrackedAtomic is unprotected and thus will be loaded as it appears on
-  // disk.
-  ExpectStringValueEquals(kTrackedAtomic, kBarfoo);
-
-  // If preference tracking is supported, the tampered value of kProtectedAtomic
-  // will be discarded at load time, leaving this preference undefined.
-  EXPECT_NE(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
-            pref_store_->GetValue(kProtectedAtomic, NULL));
-  VerifyResetRecorded(
-      ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking);
-
-  LoadExistingPrefs();
-
-  // In a subsequent launch, the local state hash store would be reset.
-  ASSERT_FALSE(local_state_.GetUserPrefValue(
-      PrefServiceHashStoreContents::kProfilePreferenceHashes));
-
-  ExpectStringValueEquals(kTrackedAtomic, kBarfoo);
-  VerifyResetRecorded(false);
-}
-
 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 149 matching lines @@
 
   // Trigger the logic that migrates it back to the unprotected preferences
   // file.
   pref_store_->SetValue(kProtectedAtomic,
                         base::WrapUnique(new base::StringValue(kGoodbyeWorld)),
                         WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   LoadExistingPrefs();
   ExpectStringValueEquals(kProtectedAtomic, kGoodbyeWorld);
   VerifyResetRecorded(false);
 }