Second batch of fixing prefs registrations.

chrome/browser/sync/invalidations/invalidator_storage_unittest.cc

 // Copyright (c) 2012 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/sync/invalidations/invalidator_storage.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
@@ skipping 29 matching lines @@
 }  // namespace
 
 class InvalidatorStorageTest : public testing::Test {
  public:
   InvalidatorStorageTest()
       : kBookmarksId_(kChromeSyncSourceId, "BOOKMARK"),
         kPreferencesId_(kChromeSyncSourceId, "PREFERENCE"),
         kAppNotificationsId_(kChromeSyncSourceId, "APP_NOTIFICATION"),
         kAutofillId_(kChromeSyncSourceId, "AUTOFILL") {}
 
+  void SetUp() {
+    InvalidatorStorage::RegisterUserPrefs(pref_service_.registry());
+  }
+
  protected:
   TestingPrefServiceSyncable pref_service_;
 
   const invalidation::ObjectId kBookmarksId_;
   const invalidation::ObjectId kPreferencesId_;
   const invalidation::ObjectId kAppNotificationsId_;
   const invalidation::ObjectId kAutofillId_;
 
   MessageLoop loop_;
 };
 
 // Set invalidation states for various keys and verify that they are written and
 // read back correctly.
 TEST_F(InvalidatorStorageTest, SetMaxVersionAndPayload) {
-  InvalidatorStorage storage(&pref_service_, pref_service_.registry());
+  InvalidatorStorage storage(&pref_service_);
 
   InvalidationStateMap expected_states;
   EXPECT_EQ(expected_states, storage.GetAllInvalidationStates());
 
   expected_states[kBookmarksId_].version = 2;
   expected_states[kBookmarksId_].payload = "hello";
   storage.SetMaxVersionAndPayload(kBookmarksId_, 2, "hello");
   EXPECT_EQ(expected_states, storage.GetAllInvalidationStates());
 
   expected_states[kPreferencesId_].version = 5;
   storage.SetMaxVersionAndPayload(kPreferencesId_, 5, std::string());
   EXPECT_EQ(expected_states, storage.GetAllInvalidationStates());
 
   expected_states[kAppNotificationsId_].version = 3;
   expected_states[kAppNotificationsId_].payload = "world";
   storage.SetMaxVersionAndPayload(kAppNotificationsId_, 3, "world");
   EXPECT_EQ(expected_states, storage.GetAllInvalidationStates());
 
   expected_states[kAppNotificationsId_].version = 4;
   expected_states[kAppNotificationsId_].payload = "again";
   storage.SetMaxVersionAndPayload(kAppNotificationsId_, 4, "again");
   EXPECT_EQ(expected_states, storage.GetAllInvalidationStates());
 }
 
 // Forgetting an entry should cause that entry to be deleted.
 TEST_F(InvalidatorStorageTest, Forget) {
-  InvalidatorStorage storage(&pref_service_, pref_service_.registry());
+  InvalidatorStorage storage(&pref_service_);
   EXPECT_TRUE(storage.GetAllInvalidationStates().empty());
 
   InvalidationStateMap expected_states;
   expected_states[kBookmarksId_].version = 2;
   expected_states[kBookmarksId_].payload = "a";
   expected_states[kPreferencesId_].version = 5;
   expected_states[kPreferencesId_].payload = "b";
   storage.SetMaxVersionAndPayload(kBookmarksId_, 2, "a");
   storage.SetMaxVersionAndPayload(kPreferencesId_, 5, "b");
   EXPECT_EQ(expected_states, storage.GetAllInvalidationStates());
 
   expected_states.erase(kPreferencesId_);
   syncer::ObjectIdSet to_forget;
   to_forget.insert(kPreferencesId_);
   storage.Forget(to_forget);
   EXPECT_EQ(expected_states, storage.GetAllInvalidationStates());
 }
 
 // Clearing the storage should erase all version map entries, bootstrap data,
 // and the client ID.
 TEST_F(InvalidatorStorageTest, Clear) {
-  InvalidatorStorage storage(&pref_service_, pref_service_.registry());
+  InvalidatorStorage storage(&pref_service_);
   EXPECT_TRUE(storage.GetAllInvalidationStates().empty());
   EXPECT_TRUE(storage.GetBootstrapData().empty());
   EXPECT_TRUE(storage.GetInvalidatorClientId().empty());
 
   storage.SetInvalidatorClientId("fake_id");
   EXPECT_EQ("fake_id", storage.GetInvalidatorClientId());
 
   storage.SetBootstrapData("test");
   EXPECT_EQ("test", storage.GetBootstrapData());
 
@@ skipping 257 matching lines @@
 }
 
 // Test that the migration code for the legacy preference works as expected.
 // Migration should happen on construction of InvalidatorStorage.
 TEST_F(InvalidatorStorageTest, MigrateLegacyPreferences) {
   base::DictionaryValue* legacy_dict = new DictionaryValue;
   legacy_dict->SetString(base::IntToString(syncer::AUTOFILL), "10");
   legacy_dict->SetString(base::IntToString(syncer::BOOKMARKS), "32");
   legacy_dict->SetString(base::IntToString(syncer::PREFERENCES), "54");
   pref_service_.SetUserPref(prefs::kSyncMaxInvalidationVersions, legacy_dict);
-  InvalidatorStorage storage(&pref_service_, pref_service_.registry());
+  InvalidatorStorage storage(&pref_service_);
 
   // Legacy pref should be cleared.
   const base::DictionaryValue* dict =
       pref_service_.GetDictionary(prefs::kSyncMaxInvalidationVersions);
   EXPECT_TRUE(dict->empty());
 
   // Validate the new pref is set correctly.
   InvalidationStateMap map;
   const base::ListValue* list =
       pref_service_.GetList(prefs::kInvalidatorMaxInvalidationVersions);
   InvalidatorStorage::DeserializeFromList(*list, &map);
 
   EXPECT_EQ(3U, map.size());
   EXPECT_EQ(10, map[kAutofillId_].version);
   EXPECT_EQ(32, map[kBookmarksId_].version);
   EXPECT_EQ(54, map[kPreferencesId_].version);
 }
 
 TEST_F(InvalidatorStorageTest, SetGetNotifierClientId) {
-  InvalidatorStorage storage(&pref_service_, pref_service_.registry());
+  InvalidatorStorage storage(&pref_service_);
   const std::string client_id("fK6eDzAIuKqx9A4+93bljg==");
 
   storage.SetInvalidatorClientId(client_id);
   EXPECT_EQ(client_id, storage.GetInvalidatorClientId());
 }
 
 TEST_F(InvalidatorStorageTest, SetGetBootstrapData) {
-  InvalidatorStorage storage(&pref_service_, pref_service_.registry());
+  InvalidatorStorage storage(&pref_service_);
   const std::string mess("n\0tK\0\0l\344", 8);
   ASSERT_FALSE(IsStringUTF8(mess));
 
   storage.SetBootstrapData(mess);
   EXPECT_EQ(mess, storage.GetBootstrapData());
 }
 
 // Test that we correctly generate ack handles, acknowledge them, and persist
 // them.
 TEST_F(InvalidatorStorageTest, GenerateAckHandlesAndAcknowledge) {
-  InvalidatorStorage storage(&pref_service_, pref_service_.registry());
+  InvalidatorStorage storage(&pref_service_);
   syncer::ObjectIdSet ids;
   InvalidationStateMap state_map;
   syncer::AckHandleMap ack_handle_map;
   syncer::AckHandleMap::const_iterator it;
 
   // Test that it works as expected if the key doesn't already exist in the map,
   // e.g. the first invalidation received for the object ID was not for a
   // specific version.
   ids.insert(kAutofillId_);
   storage.GenerateAckHandles(
@@ skipping 53 matching lines @@
   EXPECT_TRUE(it->second.IsValid());
   state_map[kBookmarksId_].expected = it->second;
   EXPECT_EQ(state_map, storage.GetAllInvalidationStates());
 
   storage.Acknowledge(kBookmarksId_, it->second);
   state_map[kBookmarksId_].current = it->second;
   EXPECT_EQ(state_map, storage.GetAllInvalidationStates());
 }
 
 }  // namespace browser_sync