Introduce PrefRegistrySyncable, simplifying PrefServiceSyncable.

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 43 matching lines @@
   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_);
+  InvalidatorStorage storage(&pref_service_, pref_service_.registry());
 
   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_);
+  InvalidatorStorage storage(&pref_service_, pref_service_.registry());
   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 and the bootstrap
 // data.
 TEST_F(InvalidatorStorageTest, Clear) {
-  InvalidatorStorage storage(&pref_service_);
+  InvalidatorStorage storage(&pref_service_, pref_service_.registry());
   EXPECT_TRUE(storage.GetAllInvalidationStates().empty());
   EXPECT_TRUE(storage.GetBootstrapData().empty());
 
   storage.SetBootstrapData("test");
   EXPECT_EQ("test", storage.GetBootstrapData());
   {
     InvalidationStateMap expected_states;
     expected_states[kAppNotificationsId_].version = 3;
     storage.SetMaxVersionAndPayload(kAppNotificationsId_, 3, std::string());
     EXPECT_EQ(expected_states, storage.GetAllInvalidationStates());
@@ skipping 251 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_);
+  InvalidatorStorage storage(&pref_service_, pref_service_.registry());
 
   // 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, SetGetBootstrapData) {
-  InvalidatorStorage storage(&pref_service_);
+  InvalidatorStorage storage(&pref_service_, pref_service_.registry());
   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_);
+  InvalidatorStorage storage(&pref_service_, pref_service_.registry());
   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