Revert of Pref service: add support for tracked 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>
@@ skipping 15 matching lines @@
 #include "base/values.h"
 #include "chrome/common/chrome_features.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 "content/public/common/service_names.mojom.h"
-#include "mojo/public/cpp/bindings/binding_set.h"
 #include "services/preferences/public/cpp/pref_service_main.h"
 #include "services/preferences/public/cpp/tracked/configuration.h"
 #include "services/preferences/public/cpp/tracked/mock_validation_delegate.h"
 #include "services/preferences/public/cpp/tracked/pref_names.h"
 #include "services/preferences/public/interfaces/preferences.mojom.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/service_manager/public/cpp/service_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
@@ skipping 84 matching lines @@
     {0u, kTrackedAtomic, EnforcementLevel::NO_ENFORCEMENT,
      PrefTrackingStrategy::ATOMIC},
     {1u, kProtectedAtomic, EnforcementLevel::ENFORCE_ON_LOAD,
      PrefTrackingStrategy::ATOMIC}};
 
 const size_t kExtraReportingId = 2u;
 const size_t kReportingIdCount = 3u;
 
 }  // namespace
 
-class ProfilePrefStoreManagerTest : public testing::TestWithParam<bool>,
-                                    public prefs::mojom::ResetOnLoadObserver {
+class ProfilePrefStoreManagerTest : public testing::TestWithParam<bool> {
  public:
   ProfilePrefStoreManagerTest()
       : configuration_(prefs::ConstructTrackedConfiguration(kConfiguration)),
         profile_pref_registry_(new user_prefs::PrefRegistrySyncable),
         registry_verifier_(profile_pref_registry_.get()),
         seed_("seed"),
         reset_recorded_(false) {}
 
   void SetUp() override {
     worker_pool_ = base::MakeUnique<base::SequencedWorkerPoolOwner>(
@@ skipping 14 matching lines @@
                      prefs::mojom::PrefStoreConnector::Name_));
       test_api.OverrideBinderForTesting(
           prefs::mojom::kServiceName, prefs::mojom::PrefServiceControl::Name_,
           base::Bind(&ProfilePrefStoreManagerTest::BindInterface,
                      base::Unretained(this),
                      prefs::mojom::PrefServiceControl::Name_));
     } else {
       feature_list_.InitAndDisableFeature(features::kPrefService);
     }
     mock_validation_delegate_record_ = new MockValidationDelegateRecord;
-    mock_validation_delegate_ = base::MakeUnique<MockValidationDelegate>(
-        mock_validation_delegate_record_);
-
     ProfilePrefStoreManager::RegisterProfilePrefs(profile_pref_registry_.get());
     for (const prefs::TrackedPreferenceMetadata* it = kConfiguration;
          it != kConfiguration + arraysize(kConfiguration); ++it) {
       if (it->strategy == 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.
     prefs::TrackedPreferenceMetadata pref_reset_time_config = {
         (*configuration_.rbegin())->reporting_id + 1,
         user_prefs::kPreferenceResetTime, EnforcementLevel::ENFORCE_ON_LOAD,
         PrefTrackingStrategy::ATOMIC};
     configuration_.push_back(
         prefs::ConstructTrackedMetadata(pref_reset_time_config));
 
     ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
     ReloadConfiguration();
   }
 
   void ReloadConfiguration() {
     RelaunchPrefService();
-    manager_.reset(new ProfilePrefStoreManager(profile_dir_.GetPath(), seed_,
-                                               "device_id"));
+    manager_.reset(new ProfilePrefStoreManager(
+        profile_dir_.GetPath(),
+        prefs::CloneTrackedConfiguration(configuration_), kReportingIdCount,
+        seed_, "device_id", &local_state_));
   }
 
   void TearDown() override {
     DestroyPrefStore();
     if (GetParam()) {
       connector_.reset();
       pref_service_context_.reset();
     }
     worker_pool_.reset();
   }
 
  protected:
+  bool SupportsPreferenceTracking() {
+    return ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking &&
+           !GetParam();
+  }
+
   void RelaunchPrefService() {
     if (!GetParam())
       return;
 
     service_manager::mojom::ServicePtr service_ptr;
     pref_service_context_ = base::MakeUnique<service_manager::ServiceContext>(
         prefs::CreatePrefService(std::set<PrefValueStore::PrefStoreType>(),
                                  worker_pool_->pool()),
         mojo::MakeRequest(&service_ptr));
   }
 
-  // Verifies whether a reset was reported via the OnResetOnLoad() hook. Also
+  // Verifies whether a reset was reported via the RecordReset() hook. Also
   // verifies that GetResetTime() was set (or not) accordingly.
   void VerifyResetRecorded(bool reset_expected) {
-    base::RunLoop().RunUntilIdle();
     EXPECT_EQ(reset_expected, reset_recorded_);
 
     PrefServiceFactory pref_service_factory;
     pref_service_factory.set_user_prefs(pref_store_);
 
     std::unique_ptr<PrefService> pref_service(
         pref_service_factory.Create(profile_pref_registry_.get()));
 
     EXPECT_EQ(
         reset_expected,
         !ProfilePrefStoreManager::GetResetTime(pref_service.get()).is_null());
   }
 
   void ClearResetRecorded() {
     reset_recorded_ = false;
 
     PrefServiceFactory pref_service_factory;
     pref_service_factory.set_user_prefs(pref_store_);
 
     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_);
     scoped_refptr<PersistentPrefStore> pref_store =
         manager_->CreateProfilePrefStore(
-            prefs::CloneTrackedConfiguration(configuration_), kReportingIdCount,
-            worker_pool_->pool().get(),
-            reset_on_load_observer_bindings_.CreateInterfacePtrAndBind(this),
-            mock_validation_delegate_bindings_.CreateInterfacePtrAndBind(
-                mock_validation_delegate_.get()),
-            connector_.get(), profile_pref_registry_);
+            main_message_loop_.task_runner(),
+            base::Bind(&ProfilePrefStoreManagerTest::RecordReset,
+                       base::Unretained(this)),
+            mock_validation_delegate_.get(), connector_.get(),
+            profile_pref_registry_);
     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.
@@ skipping 34 matching lines @@
     base::RunLoop run_loop;
     JsonPrefStore::GetTaskRunnerForFile(profile_dir_.GetPath(),
                                         worker_pool_->pool().get())
         ->PostTaskAndReply(FROM_HERE, base::Bind(&base::DoNothing),
                            run_loop.QuitClosure());
     run_loop.Run();
   }
 
   void LoadExistingPrefs() {
     DestroyPrefStore();
+    // Constructing the PrefStore consumes the tracking configuration in
+    // |manager_|, so recreate it before constructing another PrefStore.
+    ReloadConfiguration();
+    mock_validation_delegate_ = base::MakeUnique<MockValidationDelegate>(
+        mock_validation_delegate_record_);
     pref_store_ = manager_->CreateProfilePrefStore(
-        prefs::CloneTrackedConfiguration(configuration_), kReportingIdCount,
-        worker_pool_->pool().get(),
-        reset_on_load_observer_bindings_.CreateInterfacePtrAndBind(this),
-        mock_validation_delegate_bindings_.CreateInterfacePtrAndBind(
-            mock_validation_delegate_.get()),
-        connector_.get(), profile_pref_registry_);
+        JsonPrefStore::GetTaskRunnerForFile(profile_dir_.GetPath(),
+                                            worker_pool_->pool().get()),
+        base::Bind(&ProfilePrefStoreManagerTest::RecordReset,
+                   base::Unretained(this)),
+        mock_validation_delegate_.get(), connector_.get(),
+        profile_pref_registry_);
     pref_store_->AddObserver(&registry_verifier_);
     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);
 
@@ skipping 16 matching lines @@
       ADD_FAILURE() << name << " is not a defined value.";
     } else if (!value->GetAsString(&as_string)) {
       ADD_FAILURE() << name << " could not be coerced to a string.";
     } else {
       EXPECT_EQ(expected, as_string);
     }
   }
 
   void ExpectValidationObserved(const std::string& pref_path) {
     // No validations are expected for platforms that do not support tracking.
-    if (!ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking)
+    if (!SupportsPreferenceTracking())
       return;
     if (!mock_validation_delegate_record_->GetEventForPath(pref_path))
       ADD_FAILURE() << "No validation observed for preference: " << pref_path;
   }
 
   base::MessageLoop main_message_loop_;
   std::vector<prefs::mojom::TrackedPreferenceMetadataPtr> 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_;
-  mojo::BindingSet<prefs::mojom::TrackedPreferenceValidationDelegate>
-      mock_validation_delegate_bindings_;
+  std::unique_ptr<prefs::mojom::TrackedPreferenceValidationDelegate>
+      mock_validation_delegate_;
   std::unique_ptr<ProfilePrefStoreManager> manager_;
   scoped_refptr<PersistentPrefStore> pref_store_;
 
   std::string seed_;
 
  private:
-  void OnResetOnLoad() override {
+  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).
     EXPECT_FALSE(reset_recorded_);
     reset_recorded_ = true;
   }
 
   void BindInterface(const std::string& interface_name,
                      mojo::ScopedMessagePipeHandle handle) {
     service_manager::ServiceInfo source(
         service_manager::Identity(content::mojom::kBrowserServiceName,
                                   service_manager::mojom::kRootUserID),
         service_manager::InterfaceProviderSpecMap());
     static_cast<service_manager::mojom::Service*>(pref_service_context_.get())
         ->OnBindInterface(source, interface_name, std::move(handle),
                           base::Bind(&base::DoNothing));
   }
 
   base::test::ScopedFeatureList feature_list_;
   bool reset_recorded_;
   std::unique_ptr<base::SequencedWorkerPoolOwner> worker_pool_;
   std::unique_ptr<service_manager::ServiceContext> pref_service_context_;
   std::unique_ptr<service_manager::Connector> connector_;
   service_manager::mojom::ConnectorRequest connector_request_;
-  mojo::BindingSet<prefs::mojom::ResetOnLoadObserver>
-      reset_on_load_observer_bindings_;
 };
 
 TEST_P(ProfilePrefStoreManagerTest, StoreValues) {
   InitializePrefs();
 
   LoadExistingPrefs();
 
   ExpectStringValueEquals(kTrackedAtomic, kFoobar);
   ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
   VerifyResetRecorded(false);
   ExpectValidationObserved(kTrackedAtomic);
   ExpectValidationObserved(kProtectedAtomic);
 }
 
 TEST_P(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_NE(ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking,
+  EXPECT_NE(SupportsPreferenceTracking(),
             pref_store_->GetValue(kProtectedAtomic, NULL));
-  VerifyResetRecorded(
-      ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking);
+  VerifyResetRecorded(SupportsPreferenceTracking());
 
   ExpectValidationObserved(kTrackedAtomic);
   ExpectValidationObserved(kProtectedAtomic);
 }
 
 TEST_P(ProfilePrefStoreManagerTest, InitializePrefsFromMasterPrefs) {
   auto master_prefs = base::MakeUnique<base::DictionaryValue>();
   master_prefs->Set(kTrackedAtomic, new base::Value(kFoobar));
   master_prefs->Set(kProtectedAtomic, new base::Value(kHelloWorld));
-  EXPECT_TRUE(manager_->InitializePrefsFromMasterPrefs(
-      prefs::CloneTrackedConfiguration(configuration_), kReportingIdCount,
-      std::move(master_prefs)));
+  EXPECT_TRUE(
+      manager_->InitializePrefsFromMasterPrefs(std::move(master_prefs)));
 
   LoadExistingPrefs();
 
   // Verify that InitializePrefsFromMasterPrefs correctly applied the MACs
   // necessary to authenticate these values.
   ExpectStringValueEquals(kTrackedAtomic, kFoobar);
   ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
   VerifyResetRecorded(false);
 }
 
@@ skipping 30 matching lines @@
   ExpectStringValueEquals(kUnprotectedPref, kBarfoo);
   VerifyResetRecorded(false);
 
   // 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,
+  EXPECT_NE(SupportsPreferenceTracking(),
             pref_store_->GetValue(kUnprotectedPref, NULL));
-  VerifyResetRecorded(
-      ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking);
+  VerifyResetRecorded(SupportsPreferenceTracking());
 }
 
 TEST_P(ProfilePrefStoreManagerTest, NewPrefWhenFirstProtecting) {
   std::vector<prefs::mojom::TrackedPreferenceMetadataPtr>
       original_configuration = prefs::CloneTrackedConfiguration(configuration_);
   for (const auto& metadata : configuration_) {
     metadata->enforcement_level = EnforcementLevel::NO_ENFORCEMENT;
   }
   ReloadConfiguration();
 
@@ skipping 37 matching lines @@
       PrefTrackingStrategy::ATOMIC};
   configuration_.push_back(prefs::ConstructTrackedMetadata(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,
+  EXPECT_NE(SupportsPreferenceTracking(),
             pref_store_->GetValue(kUnprotectedPref, NULL));
-  VerifyResetRecorded(
-      ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking);
+  VerifyResetRecorded(SupportsPreferenceTracking());
 }
 
 // This test verifies that preference values are correctly maintained when a
 // preference's protection state changes from protected to unprotected.
 TEST_P(ProfilePrefStoreManagerTest, ProtectedToUnprotected) {
   InitializePrefs();
 
   ExpectValidationObserved(kTrackedAtomic);
   ExpectValidationObserved(kProtectedAtomic);
 
@@ skipping 24 matching lines @@
   // 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);
 }
 
-// The parameter controls whether the user pref store is created within a
-// service.
 INSTANTIATE_TEST_CASE_P(ProfilePrefStoreManagerTest,
                         ProfilePrefStoreManagerTest,
                         testing::Bool());