WIP: Pref service user prefs.

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 <utility>
 #include <vector>
 
+#include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #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 "services/preferences/public/cpp/persistent_pref_store_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 class FirstEqualsPredicate {
  public:
   explicit FirstEqualsPredicate(const std::string& expected)
       : expected_(expected) {}
   bool operator()(const PrefValueMap::Map::value_type& pair) {
     return pair.first == expected_;
@@ skipping 18 matching lines @@
                              FirstEqualsPredicate(key)))
         << "Unregistered key " << key << " was changed.";
   }
 
   void OnInitializationCompleted(bool succeeded) override {}
 
  private:
   scoped_refptr<PrefRegistry> pref_registry_;
 };
 
+class PrefStoreReadObserver : public PrefStore::Observer {
+ public:
+  explicit PrefStoreReadObserver(scoped_refptr<PersistentPrefStore> pref_store)
+      : pref_store_(std::move(pref_store)) {
+    pref_store_->AddObserver(this);
+  }
+
+  ~PrefStoreReadObserver() override { pref_store_->RemoveObserver(this); }
+
+  PersistentPrefStore::PrefReadError Read() {
+    base::RunLoop run_loop;
+    stop_waiting_ = run_loop.QuitClosure();
+    pref_store_->ReadPrefsAsync(nullptr);
+    run_loop.Run();
+    return pref_store_->GetReadError();
+  }
+
+  // PrefStore::Observer implementation
+  void OnPrefValueChanged(const std::string& key) override {}
+
+  void OnInitializationCompleted(bool succeeded) override {
+    if (!stop_waiting_.is_null()) {
+      base::ResetAndReturn(&stop_waiting_).Run();
+    }
+  }
+
+ private:
+  scoped_refptr<PersistentPrefStore> pref_store_;
+  base::Closure stop_waiting_;
+};
+
 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,
-     PrefHashFilter::TRACKING_STRATEGY_ATOMIC},
-    {1u, kProtectedAtomic, PrefHashFilter::ENFORCE_ON_LOAD,
-     PrefHashFilter::TRACKING_STRATEGY_ATOMIC}};
+    {0u, kTrackedAtomic, PrefHashFilter::EnforcementLevel::NO_ENFORCEMENT,
+     PrefHashFilter::PrefTrackingStrategy::ATOMIC},
+    {1u, kProtectedAtomic, PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD,
+     PrefHashFilter::PrefTrackingStrategy::ATOMIC}};
 
 const size_t kExtraReportingId = 2u;
 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_.get()),
         seed_("seed"),
         reset_recorded_(false) {}
 
   void SetUp() override {
     mock_validation_delegate_record_ = new MockValidationDelegateRecord;
-    mock_validation_delegate_ = base::MakeUnique<MockValidationDelegate>(
-        mock_validation_delegate_record_);
     ProfilePrefStoreManager::RegisterProfilePrefs(profile_pref_registry_.get());
     for (const PrefHashFilter::TrackedPreferenceMetadata* it = kConfiguration;
          it != kConfiguration + arraysize(kConfiguration);
          ++it) {
-      if (it->strategy == PrefHashFilter::TRACKING_STRATEGY_ATOMIC) {
+      if (it->strategy == PrefHashFilter::PrefTrackingStrategy::ATOMIC) {
         profile_pref_registry_->RegisterStringPref(it->name, std::string());
       } else {
         profile_pref_registry_->RegisterDictionaryPref(it->name);
       }
     }
     profile_pref_registry_->RegisterStringPref(kUnprotectedPref, std::string());
 
     // 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,
-         user_prefs::kPreferenceResetTime,
-         PrefHashFilter::ENFORCE_ON_LOAD,
-         PrefHashFilter::TRACKING_STRATEGY_ATOMIC};
+    PrefHashFilter::TrackedPreferenceMetadata pref_reset_time_config = {
+        configuration_.rbegin()->reporting_id + 1,
+        user_prefs::kPreferenceResetTime,
+        PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD,
+        PrefHashFilter::PrefTrackingStrategy::ATOMIC};
     configuration_.push_back(pref_reset_time_config);
 
     ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
     ReloadConfiguration();
   }
 
   void ReloadConfiguration() {
     manager_.reset(new ProfilePrefStoreManager(
         profile_dir_.GetPath(), configuration_, kReportingIdCount, seed_,
         "device_id", &local_state_));
@@ skipping 26 matching lines @@
 
     std::unique_ptr<PrefService> pref_service(
         pref_service_factory.Create(profile_pref_registry_.get()));
 
     ProfilePrefStoreManager::ClearResetTime(pref_service.get());
   }
 
   void InitializePrefs() {
     // According to the implementation of ProfilePrefStoreManager, this is
     // actually a SegregatedPrefStore backed by two underlying pref stores.
+    mock_validation_delegate_ = base::MakeUnique<MockValidationDelegate>(
+        mock_validation_delegate_record_);
+    prefs::mojom::PersistentPrefStoreConnectorPtr connector;
     scoped_refptr<PersistentPrefStore> pref_store =
         manager_->CreateProfilePrefStore(
-            main_message_loop_.task_runner(),
+            main_message_loop_.task_runner(), main_message_loop_.task_runner(),
             base::Bind(&ProfilePrefStoreManagerTest::RecordReset,
                        base::Unretained(this)),
-            mock_validation_delegate_.get());
+            &mock_validation_delegate_, &connector);
+    if (!pref_store) {
+      ASSERT_TRUE(connector);
+      pref_store = new prefs::PersistentPrefStoreMojo(std::move(connector));
+    }
     InitializePrefStore(pref_store.get());
     pref_store = NULL;
     base::RunLoop().RunUntilIdle();
   }
 
   void DestroyPrefStore() {
     if (pref_store_.get()) {
       ClearResetRecorded();
       // 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();
     }
   }
 
   void InitializePrefStore(PersistentPrefStore* pref_store) {
     pref_store->AddObserver(&registry_verifier_);
-    PersistentPrefStore::PrefReadError error = pref_store->ReadPrefs();
+    PrefStoreReadObserver read_observer(pref_store);
+    PersistentPrefStore::PrefReadError error = read_observer.Read();
     EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NO_FILE, error);
     pref_store->SetValue(kTrackedAtomic, base::MakeUnique<base::Value>(kFoobar),
                          WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
     pref_store->SetValue(kProtectedAtomic,
                          base::MakeUnique<base::Value>(kHelloWorld),
                          WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
     pref_store->SetValue(kUnprotectedPref,
                          base::MakeUnique<base::Value>(kFoobar),
                          WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
     pref_store->RemoveObserver(&registry_verifier_);
     pref_store->CommitPendingWrite();
     base::RunLoop().RunUntilIdle();
   }
 
   void LoadExistingPrefs() {
     DestroyPrefStore();
+    std::unique_ptr<prefs::mojom::TrackedPreferenceValidationDelegate>
+        validation_delegate;
+    prefs::mojom::PersistentPrefStoreConnectorPtr connector;
     pref_store_ = manager_->CreateProfilePrefStore(
-        main_message_loop_.task_runner(),
+        main_message_loop_.task_runner(), main_message_loop_.task_runner(),
         base::Bind(&ProfilePrefStoreManagerTest::RecordReset,
                    base::Unretained(this)),
-        NULL);
+        &validation_delegate, &connector);
+    if (!pref_store_) {
+      ASSERT_TRUE(connector);
+      pref_store_ = new prefs::PersistentPrefStoreMojo(std::move(connector));
+    }
     pref_store_->AddObserver(&registry_verifier_);
-    pref_store_->ReadPrefs();
+    PrefStoreReadObserver read_observer(pref_store_);
+    read_observer.Read();
   }
 
   void ReplaceStringInPrefs(const std::string& find,
                             const std::string& replace) {
     base::FileEnumerator file_enum(profile_dir_.GetPath(), true,
                                    base::FileEnumerator::FILES);
 
     for (base::FilePath path = file_enum.Next(); !path.empty();
          path = file_enum.Next()) {
       // Tamper with the file's contents
@@ skipping 26 matching lines @@
       ADD_FAILURE() << "No validation observed for preference: " << pref_path;
   }
 
   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_;
   scoped_refptr<MockValidationDelegateRecord> mock_validation_delegate_record_;
-  std::unique_ptr<MockValidationDelegate> mock_validation_delegate_;
+  std::unique_ptr<prefs::mojom::TrackedPreferenceValidationDelegate>
+      mock_validation_delegate_;
   std::unique_ptr<ProfilePrefStoreManager> manager_;
   scoped_refptr<PersistentPrefStore> pref_store_;
 
   std::string seed_;
 
  private:
   void RecordReset() {
     // As-is |reset_recorded_| is only designed to remember a single reset, make
     // sure none was previously recorded (or that ClearResetRecorded() was
     // called).
@@ skipping 68 matching lines @@
   DestroyPrefStore();
 
   ReplaceStringInPrefs(kFoobar, kBarfoo);
 
   // It's unprotected, so we can load the modified value.
   LoadExistingPrefs();
   ExpectStringValueEquals(kUnprotectedPref, kBarfoo);
 
   // Now update the configuration to protect it.
   PrefHashFilter::TrackedPreferenceMetadata new_protected = {
-      kExtraReportingId, kUnprotectedPref, PrefHashFilter::ENFORCE_ON_LOAD,
-      PrefHashFilter::TRACKING_STRATEGY_ATOMIC};
+      kExtraReportingId, kUnprotectedPref,
+      PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD,
+      PrefHashFilter::PrefTrackingStrategy::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 protected preference.
   ExpectStringValueEquals(kUnprotectedPref, kBarfoo);
   VerifyResetRecorded(false);
@@ skipping 11 matching lines @@
       ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking);
 }
 
 TEST_F(ProfilePrefStoreManagerTest, NewPrefWhenFirstProtecting) {
   std::vector<PrefHashFilter::TrackedPreferenceMetadata>
       original_configuration = configuration_;
   for (std::vector<PrefHashFilter::TrackedPreferenceMetadata>::iterator it =
            configuration_.begin();
        it != configuration_.end();
        ++it) {
-    it->enforcement_level = PrefHashFilter::NO_ENFORCEMENT;
+    it->enforcement_level = PrefHashFilter::EnforcementLevel::NO_ENFORCEMENT;
   }
   ReloadConfiguration();
 
   InitializePrefs();
 
   ExpectValidationObserved(kTrackedAtomic);
   ExpectValidationObserved(kProtectedAtomic);
 
   LoadExistingPrefs();
   ExpectStringValueEquals(kUnprotectedPref, kFoobar);
 
   // Ensure everything is written out to disk.
   DestroyPrefStore();
 
   // Now introduce protection, including the never-before tracked "new_pref".
   configuration_ = original_configuration;
   PrefHashFilter::TrackedPreferenceMetadata new_protected = {
-      kExtraReportingId, kUnprotectedPref, PrefHashFilter::ENFORCE_ON_LOAD,
-      PrefHashFilter::TRACKING_STRATEGY_ATOMIC};
+      kExtraReportingId, kUnprotectedPref,
+      PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD,
+      PrefHashFilter::PrefTrackingStrategy::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 tracked & protected preference.
   ExpectStringValueEquals(kUnprotectedPref, kFoobar);
   VerifyResetRecorded(false);
 }
 
 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};
+      kExtraReportingId, kUnprotectedPref,
+      PrefHashFilter::EnforcementLevel::ENFORCE_ON_LOAD,
+      PrefHashFilter::PrefTrackingStrategy::ATOMIC};
   configuration_.push_back(new_protected);
   seed_ = "new-seed-to-break-trust";
   ReloadConfiguration();
 
   // 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,
@@ skipping 11 matching lines @@
   ExpectValidationObserved(kProtectedAtomic);
 
   DestroyPrefStore();
 
   // 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;
+      it->enforcement_level = PrefHashFilter::EnforcementLevel::NO_ENFORCEMENT;
       break;
     }
   }
 
   seed_ = "new-seed-to-break-trust";
   ReloadConfiguration();
   LoadExistingPrefs();
 
   // Verify that the value was not reset.
   ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
   VerifyResetRecorded(false);
 
   // 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,
                         base::WrapUnique(new base::Value(kGoodbyeWorld)),
                         WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   LoadExistingPrefs();
   ExpectStringValueEquals(kProtectedAtomic, kGoodbyeWorld);
   VerifyResetRecorded(false);
 }