Changes requested by gab for previously committed CLs.

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 44 matching lines @@
                              FirstEqualsPredicate(key)))
         << "Unregistered key " << key << " was changed.";
   }
 
   virtual void OnInitializationCompleted(bool succeeded) OVERRIDE {}
 
  private:
   scoped_refptr<PrefRegistry> pref_registry_;
 };
 
-const char kUnprotectedAtomic[] = "unprotected_atomic";
+const char kUnprotectedPref[] = "unprotected_pref";
 const char kTrackedAtomic[] = "tracked_atomic";
 const char kProtectedAtomic[] = "protected_atomic";
 
 const char kFoobar[] = "FOOBAR";
 const char kBarfoo[] = "BARFOO";
 const char kHelloWorld[] = "HELLOWORLD";
 const char kGoodbyeWorld[] = "GOODBYEWORLD";
 
 const PrefHashFilter::TrackedPreferenceMetadata kConfiguration[] = {
     {0u, kTrackedAtomic, PrefHashFilter::NO_ENFORCEMENT,
@@ skipping 15 matching lines @@
         registry_verifier_(profile_pref_registry_) {}
 
   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, "", user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+            it->name,
+            std::string(),
+            user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
       } else {
         profile_pref_registry_->RegisterDictionaryPref(
             it->name, user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
       }
     }
     profile_pref_registry_->RegisterStringPref(
-        kUnprotectedAtomic,
+        kUnprotectedPref,
         std::string(),
         user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 
     ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
     ReloadConfiguration();
   }
 
   void ReloadConfiguration() {
     manager_.reset(new ProfilePrefStoreManager(profile_dir_.path(),
                                                configuration_,
@@ skipping 50 matching lines @@
     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, new base::StringValue(kFoobar));
     pref_store->SetValue(kProtectedAtomic, new base::StringValue(kHelloWorld));
-    pref_store->SetValue(kUnprotectedAtomic, new base::StringValue(kFoobar));
+    pref_store->SetValue(kUnprotectedPref, new base::StringValue(kFoobar));
     pref_store->RemoveObserver(&registry_verifier_);
     pref_store->CommitPendingWrite();
     base::RunLoop().RunUntilIdle();
   }
 
   void LoadExistingPrefs() {
     DestroyPrefStore();
     pref_store_ = manager_->CreateProfilePrefStore(
         main_message_loop_.message_loop_proxy());
     pref_store_->AddObserver(&registry_verifier_);
@@ skipping 83 matching lines @@
 
 TEST_F(ProfilePrefStoreManagerTest, ResetPrefHashStore) {
   InitializePrefs();
 
   manager_->ResetPrefHashStore();
 
   LoadExistingPrefs();
 
   // kTrackedAtomic is loaded as it appears on disk.
   ExpectStringValueEquals(kTrackedAtomic, kFoobar);
-  // If preference tracking is supported, the tampered value of kProtectedAtomic
-  // will be discarded at load time, leaving this preference undefined.
+  // 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());
 }
 
 TEST_F(ProfilePrefStoreManagerTest, ResetAllPrefHashStores) {
   InitializePrefs();
 
   ProfilePrefStoreManager::ResetAllPrefHashStores(&local_state_);
@@ skipping 40 matching lines @@
   // values.
   LoadExistingPrefs();
 
   // These expectations hold whether or not tracking is supported.
   ExpectStringValueEquals(kTrackedAtomic, kFoobar);
   ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
   EXPECT_FALSE(WasResetRecorded());
 }
 
 TEST_F(ProfilePrefStoreManagerTest, InitializePrefsFromMasterPrefs) {
-  scoped_ptr<base::DictionaryValue> master_prefs(
-      new base::DictionaryValue);
-  master_prefs->Set(kTrackedAtomic, new base::StringValue(kFoobar));
-  master_prefs->Set(kProtectedAtomic, new base::StringValue(kHelloWorld));
-  EXPECT_TRUE(
-      manager_->InitializePrefsFromMasterPrefs(*master_prefs));
+  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.
   ExpectStringValueEquals(kTrackedAtomic, kFoobar);
   ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
   EXPECT_FALSE(WasResetRecorded());
 }
 
 TEST_F(ProfilePrefStoreManagerTest, UnprotectedToProtected) {
   InitializePrefs();
   LoadExistingPrefs();
-  ExpectStringValueEquals(kUnprotectedAtomic, kFoobar);
+  ExpectStringValueEquals(kUnprotectedPref, kFoobar);
 
   // Ensure everything is written out to disk.
   DestroyPrefStore();
 
   ReplaceStringInPrefs(kFoobar, kBarfoo);
 
   // It's unprotected, so we can load the modified value.
   LoadExistingPrefs();
-  ExpectStringValueEquals(kUnprotectedAtomic, kBarfoo);
+  ExpectStringValueEquals(kUnprotectedPref, kBarfoo);
 
   // Now update the configuration to protect it.
   PrefHashFilter::TrackedPreferenceMetadata new_protected = {
-      kExtraReportingId, kUnprotectedAtomic, PrefHashFilter::ENFORCE_ON_LOAD,
+      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.
-  ExpectStringValueEquals(kUnprotectedAtomic, kBarfoo);
+  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(kUnprotectedAtomic, NULL));
+            pref_store_->GetValue(kUnprotectedPref, NULL));
   EXPECT_EQ(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             WasResetRecorded());
 }
 
 TEST_F(ProfilePrefStoreManagerTest, UnprotectedToProtectedWithoutTrust) {
   InitializePrefs();
 
   // Now update the configuration to protect it.
   PrefHashFilter::TrackedPreferenceMetadata new_protected = {
-      kExtraReportingId, kUnprotectedAtomic, PrefHashFilter::ENFORCE_ON_LOAD,
+      kExtraReportingId, kUnprotectedPref, PrefHashFilter::ENFORCE_ON_LOAD,
       PrefHashFilter::TRACKING_STRATEGY_ATOMIC};
   configuration_.push_back(new_protected);
   ReloadConfiguration();
   ProfilePrefStoreManager::ResetAllPrefHashStores(&local_state_);
 
   // And try loading with the new configuration.
   LoadExistingPrefs();
 
-  // If preference tracking is supported, kUnprotectedAtomic will have been
+  // 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(kUnprotectedAtomic, NULL));
+            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
 // preference's protection state changes from protected to unprotected.
@@ skipping 27 matching lines @@
   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());
 }