Move tracked prefs into services/preferences/tracked.

services/preferences/tracked/tracked_preferences_migration_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 "components/user_prefs/tracked/tracked_preferences_migration.h"
+#include "services/preferences/tracked/tracked_preferences_migration.h"
 
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/strings/string_split.h"
 #include "base/values.h"
 #include "components/prefs/testing_pref_service.h"
-#include "components/user_prefs/tracked/dictionary_hash_store_contents.h"
-#include "components/user_prefs/tracked/hash_store_contents.h"
-#include "components/user_prefs/tracked/interceptable_pref_filter.h"
-#include "components/user_prefs/tracked/pref_hash_store.h"
-#include "components/user_prefs/tracked/pref_hash_store_impl.h"
-#include "components/user_prefs/tracked/pref_hash_store_transaction.h"
-#include "components/user_prefs/tracked/tracked_preferences_migration.h"
+#include "services/preferences/tracked/dictionary_hash_store_contents.h"
+#include "services/preferences/tracked/hash_store_contents.h"
+#include "services/preferences/tracked/interceptable_pref_filter.h"
+#include "services/preferences/tracked/pref_hash_store.h"
+#include "services/preferences/tracked/pref_hash_store_impl.h"
+#include "services/preferences/tracked/pref_hash_store_transaction.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // An unprotected pref.
 const char kUnprotectedPref[] = "unprotected";
 // A protected pref.
 const char kProtectedPref[] = "protected";
 // A protected pref which is initially stored in the unprotected store.
 const char kPreviouslyUnprotectedPref[] = "previously.unprotected";
@@ skipping 44 matching lines @@
   };
 
   TrackedPreferencesMigrationTest()
       : unprotected_prefs_(new base::DictionaryValue),
         protected_prefs_(new base::DictionaryValue),
         migration_modified_unprotected_store_(false),
         migration_modified_protected_store_(false),
         unprotected_store_migration_complete_(false),
         protected_store_migration_complete_(false) {}
 
-  void SetUp() override {
-    Reset();
-  }
+  void SetUp() override { Reset(); }
 
   void Reset() {
     std::set<std::string> unprotected_pref_names;
     std::set<std::string> protected_pref_names;
     unprotected_pref_names.insert(kUnprotectedPref);
     unprotected_pref_names.insert(kPreviouslyProtectedPref);
     protected_pref_names.insert(kProtectedPref);
     protected_pref_names.insert(kPreviouslyUnprotectedPref);
 
     migration_modified_unprotected_store_ = false;
@@ skipping 73 matching lines @@
         return !protected_store_successful_write_callback_.is_null();
       case MOCK_PROTECTED_PREF_STORE:
         return !unprotected_store_successful_write_callback_.is_null();
     }
     NOTREACHED();
     return false;
   }
 
   // Verifies that the (key, value) pairs in |expected_prefs_in_store| are found
   // in the store identified by |store_id|.
-  void VerifyValuesStored(
-      MockPrefStoreID store_id,
-      const base::StringPairs& expected_prefs_in_store) {
+  void VerifyValuesStored(MockPrefStoreID store_id,
+                          const base::StringPairs& expected_prefs_in_store) {
     base::DictionaryValue* store = NULL;
     switch (store_id) {
       case MOCK_UNPROTECTED_PREF_STORE:
         store = unprotected_prefs_.get();
         break;
       case MOCK_PROTECTED_PREF_STORE:
         store = protected_prefs_.get();
         break;
     }
     DCHECK(store);
@@ skipping 63 matching lines @@
         return migration_modified_unprotected_store_;
       case MOCK_PROTECTED_PREF_STORE:
         return migration_modified_protected_store_;
     }
     NOTREACHED();
     return false;
   }
 
   bool MigrationCompleted() {
     return unprotected_store_migration_complete_ &&
-        protected_store_migration_complete_;
+           protected_store_migration_complete_;
   }
 
   void SimulateSuccessfulWrite(MockPrefStoreID store_id) {
     switch (store_id) {
       case MOCK_UNPROTECTED_PREF_STORE:
         EXPECT_FALSE(unprotected_store_successful_write_callback_.is_null());
         unprotected_store_successful_write_callback_.Run();
         unprotected_store_successful_write_callback_.Reset();
         break;
       case MOCK_PROTECTED_PREF_STORE:
@@ skipping 150 matching lines @@
   VerifyValuesStored(MOCK_PROTECTED_PREF_STORE, expected_protected_values);
 
   EXPECT_TRUE(ContainsHash(MOCK_UNPROTECTED_PREF_STORE, kUnprotectedPref));
   EXPECT_FALSE(ContainsHash(MOCK_UNPROTECTED_PREF_STORE, kProtectedPref));
 
   EXPECT_TRUE(ContainsHash(MOCK_PROTECTED_PREF_STORE, kProtectedPref));
   EXPECT_FALSE(ContainsHash(MOCK_PROTECTED_PREF_STORE, kUnprotectedPref));
 }
 
 TEST_F(TrackedPreferencesMigrationTest, FullMigration) {
-  PresetStoreValue(
-      MOCK_UNPROTECTED_PREF_STORE, kUnprotectedPref, kUnprotectedPrefValue);
-  PresetStoreValue(MOCK_UNPROTECTED_PREF_STORE,
-                   kPreviouslyUnprotectedPref,
+  PresetStoreValue(MOCK_UNPROTECTED_PREF_STORE, kUnprotectedPref,
+                   kUnprotectedPrefValue);
+  PresetStoreValue(MOCK_UNPROTECTED_PREF_STORE, kPreviouslyUnprotectedPref,
                    kPreviouslyUnprotectedPrefValue);
-  PresetStoreValue(
-      MOCK_PROTECTED_PREF_STORE, kProtectedPref, kProtectedPrefValue);
-  PresetStoreValue(MOCK_PROTECTED_PREF_STORE,
-                   kPreviouslyProtectedPref,
+  PresetStoreValue(MOCK_PROTECTED_PREF_STORE, kProtectedPref,
+                   kProtectedPrefValue);
+  PresetStoreValue(MOCK_PROTECTED_PREF_STORE, kPreviouslyProtectedPref,
                    kPreviouslyProtectedPrefValue);
 
   EXPECT_TRUE(ContainsHash(MOCK_UNPROTECTED_PREF_STORE, kUnprotectedPref));
   EXPECT_TRUE(
       ContainsHash(MOCK_UNPROTECTED_PREF_STORE, kPreviouslyUnprotectedPref));
   EXPECT_FALSE(ContainsHash(MOCK_UNPROTECTED_PREF_STORE, kProtectedPref));
   EXPECT_FALSE(
       ContainsHash(MOCK_UNPROTECTED_PREF_STORE, kPreviouslyProtectedPref));
 
   EXPECT_FALSE(ContainsHash(MOCK_PROTECTED_PREF_STORE, kUnprotectedPref));
@@ skipping 17 matching lines @@
       WasOnSuccessfulWriteCallbackRegistered(MOCK_UNPROTECTED_PREF_STORE));
   EXPECT_TRUE(
       WasOnSuccessfulWriteCallbackRegistered(MOCK_PROTECTED_PREF_STORE));
   EXPECT_TRUE(StoreModifiedByMigration(MOCK_UNPROTECTED_PREF_STORE));
   EXPECT_TRUE(StoreModifiedByMigration(MOCK_PROTECTED_PREF_STORE));
 
   // Values should have been migrated to their store, but migrated values should
   // still remain in the source store until cleanup tasks are later invoked.
   {
     base::StringPairs expected_unprotected_values;
-    expected_unprotected_values.push_back(std::make_pair(
-        kUnprotectedPref, kUnprotectedPrefValue));
+    expected_unprotected_values.push_back(
+        std::make_pair(kUnprotectedPref, kUnprotectedPrefValue));
     expected_unprotected_values.push_back(std::make_pair(
         kPreviouslyProtectedPref, kPreviouslyProtectedPrefValue));
     expected_unprotected_values.push_back(std::make_pair(
         kPreviouslyUnprotectedPref, kPreviouslyUnprotectedPrefValue));
     VerifyValuesStored(MOCK_UNPROTECTED_PREF_STORE,
                        expected_unprotected_values);
 
     base::StringPairs expected_protected_values;
-    expected_protected_values.push_back(std::make_pair(
-        kProtectedPref, kProtectedPrefValue));
+    expected_protected_values.push_back(
+        std::make_pair(kProtectedPref, kProtectedPrefValue));
     expected_protected_values.push_back(std::make_pair(
         kPreviouslyUnprotectedPref, kPreviouslyUnprotectedPrefValue));
     expected_unprotected_values.push_back(std::make_pair(
         kPreviouslyProtectedPref, kPreviouslyProtectedPrefValue));
     VerifyValuesStored(MOCK_PROTECTED_PREF_STORE, expected_protected_values);
 
     EXPECT_TRUE(ContainsHash(MOCK_UNPROTECTED_PREF_STORE, kUnprotectedPref));
     EXPECT_TRUE(
         ContainsHash(MOCK_UNPROTECTED_PREF_STORE, kPreviouslyUnprotectedPref));
     EXPECT_FALSE(ContainsHash(MOCK_UNPROTECTED_PREF_STORE, kProtectedPref));
     EXPECT_TRUE(
         ContainsHash(MOCK_UNPROTECTED_PREF_STORE, kPreviouslyProtectedPref));
 
     EXPECT_FALSE(ContainsHash(MOCK_PROTECTED_PREF_STORE, kUnprotectedPref));
     EXPECT_TRUE(
         ContainsHash(MOCK_PROTECTED_PREF_STORE, kPreviouslyUnprotectedPref));
     EXPECT_TRUE(ContainsHash(MOCK_PROTECTED_PREF_STORE, kProtectedPref));
     EXPECT_TRUE(
         ContainsHash(MOCK_PROTECTED_PREF_STORE, kPreviouslyProtectedPref));
   }
 
   // A successful write of the protected pref store should result in a clean up
   // of the unprotected store.
   SimulateSuccessfulWrite(MOCK_PROTECTED_PREF_STORE);
 
   {
     base::StringPairs expected_unprotected_values;
-    expected_unprotected_values.push_back(std::make_pair(
-        kUnprotectedPref, kUnprotectedPrefValue));
+    expected_unprotected_values.push_back(
+        std::make_pair(kUnprotectedPref, kUnprotectedPrefValue));
     expected_unprotected_values.push_back(std::make_pair(
         kPreviouslyProtectedPref, kPreviouslyProtectedPrefValue));
     VerifyValuesStored(MOCK_UNPROTECTED_PREF_STORE,
                        expected_unprotected_values);
 
     base::StringPairs expected_protected_values;
-    expected_protected_values.push_back(std::make_pair(
-        kProtectedPref, kProtectedPrefValue));
+    expected_protected_values.push_back(
+        std::make_pair(kProtectedPref, kProtectedPrefValue));
     expected_protected_values.push_back(std::make_pair(
         kPreviouslyUnprotectedPref, kPreviouslyUnprotectedPrefValue));
     expected_unprotected_values.push_back(std::make_pair(
         kPreviouslyProtectedPref, kPreviouslyProtectedPrefValue));
     VerifyValuesStored(MOCK_PROTECTED_PREF_STORE, expected_protected_values);
   }
 
   SimulateSuccessfulWrite(MOCK_UNPROTECTED_PREF_STORE);
 
   {
     base::StringPairs expected_unprotected_values;
-    expected_unprotected_values.push_back(std::make_pair(
-        kUnprotectedPref, kUnprotectedPrefValue));
+    expected_unprotected_values.push_back(
+        std::make_pair(kUnprotectedPref, kUnprotectedPrefValue));
     expected_unprotected_values.push_back(std::make_pair(
         kPreviouslyProtectedPref, kPreviouslyProtectedPrefValue));
     VerifyValuesStored(MOCK_UNPROTECTED_PREF_STORE,
                        expected_unprotected_values);
 
     base::StringPairs expected_protected_values;
-    expected_protected_values.push_back(std::make_pair(
-        kProtectedPref, kProtectedPrefValue));
+    expected_protected_values.push_back(
+        std::make_pair(kProtectedPref, kProtectedPrefValue));
     expected_protected_values.push_back(std::make_pair(
         kPreviouslyUnprotectedPref, kPreviouslyUnprotectedPrefValue));
     VerifyValuesStored(MOCK_PROTECTED_PREF_STORE, expected_protected_values);
   }
 
   // Hashes are not cleaned up yet.
   EXPECT_TRUE(ContainsHash(MOCK_UNPROTECTED_PREF_STORE, kUnprotectedPref));
   EXPECT_TRUE(
       ContainsHash(MOCK_UNPROTECTED_PREF_STORE, kPreviouslyUnprotectedPref));
   EXPECT_FALSE(ContainsHash(MOCK_UNPROTECTED_PREF_STORE, kProtectedPref));
@@ skipping 24 matching lines @@
   EXPECT_FALSE(ContainsHash(MOCK_PROTECTED_PREF_STORE, kUnprotectedPref));
   EXPECT_TRUE(
       ContainsHash(MOCK_PROTECTED_PREF_STORE, kPreviouslyUnprotectedPref));
   EXPECT_TRUE(ContainsHash(MOCK_PROTECTED_PREF_STORE, kProtectedPref));
   EXPECT_FALSE(
       ContainsHash(MOCK_PROTECTED_PREF_STORE, kPreviouslyProtectedPref));
 }
 
 TEST_F(TrackedPreferencesMigrationTest, CleanupOnly) {
   // Already migrated; only cleanup needed.
-  PresetStoreValue(
-      MOCK_UNPROTECTED_PREF_STORE, kUnprotectedPref, kUnprotectedPrefValue);
-  PresetStoreValue(MOCK_UNPROTECTED_PREF_STORE,
-                   kPreviouslyProtectedPref,
+  PresetStoreValue(MOCK_UNPROTECTED_PREF_STORE, kUnprotectedPref,
+                   kUnprotectedPrefValue);
+  PresetStoreValue(MOCK_UNPROTECTED_PREF_STORE, kPreviouslyProtectedPref,
                    kPreviouslyProtectedPrefValue);
-  PresetStoreValue(MOCK_UNPROTECTED_PREF_STORE,
-                   kPreviouslyUnprotectedPref,
+  PresetStoreValue(MOCK_UNPROTECTED_PREF_STORE, kPreviouslyUnprotectedPref,
                    kPreviouslyUnprotectedPrefValue);
-  PresetStoreValue(
-      MOCK_PROTECTED_PREF_STORE, kProtectedPref, kProtectedPrefValue);
-  PresetStoreValue(MOCK_PROTECTED_PREF_STORE,
-                   kPreviouslyProtectedPref,
+  PresetStoreValue(MOCK_PROTECTED_PREF_STORE, kProtectedPref,
+                   kProtectedPrefValue);
+  PresetStoreValue(MOCK_PROTECTED_PREF_STORE, kPreviouslyProtectedPref,
                    kPreviouslyProtectedPrefValue);
-  PresetStoreValue(MOCK_PROTECTED_PREF_STORE,
-                   kPreviouslyUnprotectedPref,
+  PresetStoreValue(MOCK_PROTECTED_PREF_STORE, kPreviouslyUnprotectedPref,
                    kPreviouslyUnprotectedPrefValue);
 
   HandPrefsToMigrator(MOCK_UNPROTECTED_PREF_STORE);
   EXPECT_FALSE(HasPrefs(MOCK_UNPROTECTED_PREF_STORE));
   EXPECT_TRUE(HasPrefs(MOCK_PROTECTED_PREF_STORE));
   EXPECT_FALSE(MigrationCompleted());
 
   HandPrefsToMigrator(MOCK_PROTECTED_PREF_STORE);
   EXPECT_TRUE(MigrationCompleted());
 
   EXPECT_TRUE(HasPrefs(MOCK_UNPROTECTED_PREF_STORE));
   EXPECT_TRUE(HasPrefs(MOCK_PROTECTED_PREF_STORE));
   EXPECT_FALSE(
       WasOnSuccessfulWriteCallbackRegistered(MOCK_UNPROTECTED_PREF_STORE));
   EXPECT_FALSE(
       WasOnSuccessfulWriteCallbackRegistered(MOCK_PROTECTED_PREF_STORE));
   EXPECT_FALSE(StoreModifiedByMigration(MOCK_UNPROTECTED_PREF_STORE));
   EXPECT_FALSE(StoreModifiedByMigration(MOCK_PROTECTED_PREF_STORE));
 
   // Cleanup should happen synchronously if the values were already present in
   // their destination stores.
   {
     base::StringPairs expected_unprotected_values;
-    expected_unprotected_values.push_back(std::make_pair(
-        kUnprotectedPref, kUnprotectedPrefValue));
+    expected_unprotected_values.push_back(
+        std::make_pair(kUnprotectedPref, kUnprotectedPrefValue));
     expected_unprotected_values.push_back(std::make_pair(
         kPreviouslyProtectedPref, kPreviouslyProtectedPrefValue));
     VerifyValuesStored(MOCK_UNPROTECTED_PREF_STORE,
                        expected_unprotected_values);
 
     base::StringPairs expected_protected_values;
-    expected_protected_values.push_back(std::make_pair(
-        kProtectedPref, kProtectedPrefValue));
+    expected_protected_values.push_back(
+        std::make_pair(kProtectedPref, kProtectedPrefValue));
     expected_protected_values.push_back(std::make_pair(
         kPreviouslyUnprotectedPref, kPreviouslyUnprotectedPrefValue));
     VerifyValuesStored(MOCK_PROTECTED_PREF_STORE, expected_protected_values);
   }
 }