Separate storage for protected preferences into Protected Preferences file.

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 "components/user_prefs/pref_registry_syncable.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
@@ skipping 25 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 kTrackedAtomic[] = "tracked_atomic";
 const char kProtectedAtomic[] = "protected_atomic";
 const char kProtectedSplit[] = "protected_split";
 
 const char kFoobar[] = "FOOBAR";
 const char kBarfoo[] = "BARFOO";
 const char kHelloWorld[] = "HELLOWORLD";
 const char kGoodbyeWorld[] = "GOODBYEWORLD";
 
 const PrefHashFilter::TrackedPreferenceMetadata kConfiguration[] = {
@@ skipping 21 matching lines @@
          it != kConfiguration + arraysize(kConfiguration);
          ++it) {
       if (it->strategy == PrefHashFilter::TRACKING_STRATEGY_ATOMIC) {
         profile_pref_registry_->RegisterStringPref(
             it->name, "", user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
       } else {
         profile_pref_registry_->RegisterDictionaryPref(
             it->name, user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
       }
     }
+    profile_pref_registry_->RegisterStringPref(
+        kUnprotectedAtomic,
+        std::string(),
+        user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+
     ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
+    ReloadConfiguration();
+  }
 
+  void ReloadConfiguration() {
     manager_.reset(new ProfilePrefStoreManager(profile_dir_.path(),
                                                configuration_,
                                                configuration_.size(),
                                                "seed",
                                                "device_id",
                                                &local_state_));
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() OVERRIDE { DestroyPrefStore(); }
+
+ protected:
+  bool ResetRecorded() {
+    base::PrefServiceFactory pref_service_factory;
+    pref_service_factory.set_user_prefs(pref_store_);
+    return !ProfilePrefStoreManager::GetResetTime(
+                pref_service_factory.Create(profile_pref_registry_).get())

[Bernhard Bauer, 2014/03/27 15:10:45]

This expression is a bit big. Could you extract e.g. the value returned from
pref_service_factory.Create() to a local variable?

[erikwright (departed), 2014/03/27 19:26:21]

Done.

+                .is_null();
+  }
+
+  void InitializePrefs() {
+    scoped_refptr<PersistentPrefStore> pref_store =
+        manager_->CreateProfilePrefStore(
+            main_message_loop_.message_loop_proxy());
+    InitializePrefStore(pref_store);
+    pref_store = NULL;
+    base::RunLoop().RunUntilIdle();
+  }
+
+  void DestroyPrefStore() {
     if (pref_store_) {
       // Force everything to be written to disk, triggering the PrefHashFilter
       // while our RegistryVerifier is watching.
       pref_store_->CommitPendingWrite();
       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();
     }
   }
 
- protected:
-  void InitializePrefs() {
+  void InitializeDeprecatedCombinedProfilePrefStore() {
     scoped_refptr<PersistentPrefStore> pref_store =
-        manager_->CreateProfilePrefStore(
+        manager_->CreateDeprecatedCombinedProfilePrefStore(
             main_message_loop_.message_loop_proxy());
-    pref_store->AddObserver(&registry_verifier_);
-    PersistentPrefStore::PrefReadError error = pref_store->ReadPrefs();
-    ASSERT_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->RemoveObserver(&registry_verifier_);
+    InitializePrefStore(pref_store);
     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->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_);
-    EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NONE,
-              pref_store_->ReadPrefs());
+    pref_store_->ReadPrefs();
   }
 
   void ReplaceStringInPrefs(const std::string& find,
                             const std::string& replace) {
-    // Tamper with the file's contents
-    base::FilePath pref_file_path =
-        ProfilePrefStoreManager::GetPrefFilePathFromProfilePath(
-            profile_dir_.path());
-    std::string pref_file_contents;
-    EXPECT_TRUE(base::ReadFileToString(pref_file_path, &pref_file_contents));
-    ReplaceSubstringsAfterOffset(&pref_file_contents, 0u, find, replace);
-    EXPECT_EQ(static_cast<int>(pref_file_contents.length()),
-              base::WriteFile(pref_file_path,
-                              pref_file_contents.c_str(),
-                              pref_file_contents.length()));
+    base::FileEnumerator file_enumerator(
+        profile_dir_.path(), true, base::FileEnumerator::FILES);
+
+    base::FilePath pref_file_path;
+    while (!(pref_file_path = file_enumerator.Next()).empty()) {
+      // Tamper with the file's contents
+      std::string pref_file_contents;
+      EXPECT_TRUE(base::ReadFileToString(pref_file_path, &pref_file_contents));
+      ReplaceSubstringsAfterOffset(&pref_file_contents, 0u, find, replace);
+      EXPECT_EQ(static_cast<int>(pref_file_contents.length()),
+                base::WriteFile(pref_file_path,
+                                pref_file_contents.c_str(),
+                                pref_file_contents.length()));
+    }
   }
 
   void ExpectStringValueEquals(const std::string& name,
                                const std::string& expected) {
     const base::Value* value = NULL;
     std::string as_string;
     if (!pref_store_->GetValue(name, &value)) {
       ADD_FAILURE() << name << " is not a defined value.";
     } else if (!value->GetAsString(&as_string)) {
       ADD_FAILURE() << name << " could not be coerced to a string.";
@@ skipping 12 matching lines @@
   scoped_refptr<PersistentPrefStore> pref_store_;
 };
 
 TEST_F(ProfilePrefStoreManagerTest, StoreValues) {
   InitializePrefs();
 
   LoadExistingPrefs();
 
   ExpectStringValueEquals(kTrackedAtomic, kFoobar);
   ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
+  EXPECT_FALSE(ResetRecorded());
 }
 
 TEST_F(ProfilePrefStoreManagerTest, GetPrefFilePathFromProfilePath) {
   base::FilePath pref_file_path =
       ProfilePrefStoreManager::GetPrefFilePathFromProfilePath(
           profile_dir_.path());
 
-  ASSERT_FALSE(base::PathExists(pref_file_path));
+  EXPECT_FALSE(base::PathExists(pref_file_path));
 
   InitializePrefs();
 
-  ASSERT_TRUE(base::PathExists(pref_file_path));
+  EXPECT_TRUE(base::PathExists(pref_file_path));
 }
 
 TEST_F(ProfilePrefStoreManagerTest, ProtectValues) {
   InitializePrefs();
 
   ReplaceStringInPrefs(kFoobar, kBarfoo);
   ReplaceStringInPrefs(kHelloWorld, kGoodbyeWorld);
 
   LoadExistingPrefs();
 
   // 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_EQ(!ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
+  EXPECT_NE(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             pref_store_->GetValue(kProtectedAtomic, NULL));
+  EXPECT_EQ(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
+            ResetRecorded());
 }
 
 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.
-  EXPECT_EQ(!ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
+  EXPECT_NE(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             pref_store_->GetValue(kProtectedAtomic, NULL));
+  EXPECT_EQ(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
+            ResetRecorded());
 }
 
 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_EQ(!ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
+  EXPECT_NE(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
             pref_store_->GetValue(kProtectedAtomic, NULL));
+  EXPECT_EQ(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
+            ResetRecorded());
+}
+
+TEST_F(ProfilePrefStoreManagerTest, MigrateFromOneFile) {
+  InitializeDeprecatedCombinedProfilePrefStore();
+
+  LoadExistingPrefs();
+
+  ExpectStringValueEquals(kTrackedAtomic, kFoobar);
+  ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
+  EXPECT_FALSE(ResetRecorded());
 }
 
 TEST_F(ProfilePrefStoreManagerTest, UpdateProfileHashStoreIfRequired) {
-  InitializePrefs();
-
-  manager_->ResetPrefHashStore();
+  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(ResetRecorded());
 }
 
 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));
-  ASSERT_TRUE(
+  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(ResetRecorded());
 }
+
+TEST_F(ProfilePrefStoreManagerTest, UnprotectedToProtected) {
+  InitializePrefs();
+  LoadExistingPrefs();
+  ExpectStringValueEquals(kUnprotectedAtomic, 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);
+
+  // Now update the configuration to protect it.
+  PrefHashFilter::TrackedPreferenceMetadata new_protected = {
+      99u, kUnprotectedAtomic, 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);
+  EXPECT_FALSE(ResetRecorded());
+
+  // 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));
+  EXPECT_EQ(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
+            ResetRecorded());
+}
+
+TEST_F(ProfilePrefStoreManagerTest, UnprotectedToProtectedWithoutTrust) {
+  InitializePrefs();
+
+  // Now update the configuration to protect it.
+  PrefHashFilter::TrackedPreferenceMetadata new_protected = {
+      99u, kUnprotectedAtomic, 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
+  // discarded because new values are not accepted without a valid super MAC.
+  EXPECT_NE(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
+            pref_store_->GetValue(kUnprotectedAtomic, NULL));
+  EXPECT_EQ(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
+            ResetRecorded());
+}
+
+// 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.
+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 == std::string(kProtectedAtomic)) {
+      configuration_.erase(it);
+      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(ResetRecorded());
+
+  // 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(ResetRecorded());
+}