Make SyncBackendRegistrar aware of loaded data

chrome/browser/sync/profile_sync_service_preference_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 <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
@@ skipping 42 matching lines @@
 ACTION_P(CreateAndSaveChangeProcessor, change_processor) {
   syncer::UserShare* user_share = arg0->GetUserShare();
   *change_processor = new GenericChangeProcessor(arg1, arg2, user_share);
   return *change_processor;
 }
 
 // TODO(zea): Refactor to remove the ProfileSyncService usage.
 class ProfileSyncServicePreferenceTest
     : public AbstractProfileSyncServiceTest {
  public:
-  int64 SetSyncedValue(const std::string& name, const Value& value) {
-    syncer::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
+  int64 SetSyncedValue(const std::string& name, const Value& value,
+                       syncer::UserShare* user_share) {
+    syncer::WriteTransaction trans(FROM_HERE, user_share);
     syncer::ReadNode root(&trans);
     if (root.InitByTagLookup(syncer::ModelTypeToRootTag(
             syncer::PREFERENCES)) != syncer::BaseNode::INIT_OK) {
       return syncer::kInvalidId;
     }
 
     syncer::WriteNode tag_node(&trans);
     syncer::WriteNode node(&trans);
 
     if (tag_node.InitByClientTagLookup(syncer::PREFERENCES, name) ==
@@ skipping 28 matching lines @@
                                not_synced_preference_default_value_,
                                PrefService::UNSYNCABLE_PREF);
   }
 
   virtual void TearDown() {
     service_.reset();
     profile_.reset();
     AbstractProfileSyncServiceTest::TearDown();
   }
 
-  bool StartSyncService(const base::Closure& callback,
-                        bool will_fail_association) {
+  bool StartSyncService(
+      const base::Callback<void(syncer::UserShare*)>& callback,
+      bool will_fail_association) {
     if (service_.get())
       return false;
 
     SigninManager* signin = SigninManagerFactory::GetForProfile(profile_.get());
     signin->SetAuthenticatedUsername("test");
     ProfileSyncComponentsFactoryMock* factory =
         new ProfileSyncComponentsFactoryMock();
     service_.reset(new TestProfileSyncService(
         factory,
         profile_.get(),
@@ skipping 92 matching lines @@
  public:
   AddPreferenceEntriesHelper(ProfileSyncServicePreferenceTest* test,
                              const PreferenceValues& entries)
       : ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
             base::Bind(
                 &AddPreferenceEntriesHelper::AddPreferenceEntriesCallback,
                 base::Unretained(this), test, entries))),
         success_(false) {
   }
 
-  const base::Closure& callback() const { return callback_; }
-  bool success() { return success_; }
+  const base::Callback<void(syncer::UserShare*)>& callback() const {
+    return callback_;
+  }
+
+  bool success() {
+    return success_;
+  }
 
  private:
   void AddPreferenceEntriesCallback(ProfileSyncServicePreferenceTest* test,
-                                    const PreferenceValues& entries) {
-    if (!test->CreateRoot(syncer::PREFERENCES))
+                                    const PreferenceValues& entries,
+                                    syncer::UserShare* user_share) {
+    if (!test->CreateRoot(syncer::PREFERENCES, user_share))
       return;
 
     for (PreferenceValues::const_iterator i = entries.begin();
          i != entries.end(); ++i) {
-      if (test->SetSyncedValue(i->first, *i->second) == syncer::kInvalidId)
+      if (test->SetSyncedValue(i->first, *i->second, user_share)
+          == syncer::kInvalidId) {
         return;
+      }
     }
     success_ = true;
   }
 
-  base::Closure callback_;
+  base::Callback<void(syncer::UserShare*)> callback_;
   bool success_;
 };
 
 TEST_F(ProfileSyncServicePreferenceTest, CreatePrefSyncData) {
   prefs_->SetString(prefs::kHomePage, example_url0_);
   CreateRootHelper create_root(this, syncer::PREFERENCES);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
 
   const PrefService::Preference* pref =
@@ skipping 88 matching lines @@
   ASSERT_TRUE(value.get());
   EXPECT_TRUE(static_cast<const StringValue*>(value.get())->
               GetAsString(&string_value));
   EXPECT_EQ(non_default_charset_value_, string_value);
   EXPECT_EQ(non_default_charset_value_,
             prefs_->GetString(prefs::kDefaultCharset));
   STLDeleteValues(&cloud_data);
 }
 
 TEST_F(ProfileSyncServicePreferenceTest, FailModelAssociation) {
-  ASSERT_TRUE(StartSyncService(base::Closure(), true));
+  ASSERT_TRUE(StartSyncService(TestProfileSyncService::NullCallback(), true));
   EXPECT_TRUE(service_->HasUnrecoverableError());
 }
 
 TEST_F(ProfileSyncServicePreferenceTest, UpdatedPreferenceWithDefaultValue) {
   const PrefService::Preference* pref =
       prefs_->FindPreference(prefs::kHomePage);
   EXPECT_TRUE(pref->IsDefaultValue());
 
   CreateRootHelper create_root(this, syncer::PREFERENCES);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
@@ skipping 21 matching lines @@
   EXPECT_TRUE(expected->Equals(actual.get()));
 }
 
 TEST_F(ProfileSyncServicePreferenceTest, UpdatedSyncNodeActionUpdate) {
   profile_->GetPrefs()->SetString(prefs::kHomePage, example_url0_);
   CreateRootHelper create_root(this, syncer::PREFERENCES);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
 
   scoped_ptr<Value> expected(Value::CreateStringValue(example_url1_));
-  int64 node_id = SetSyncedValue(prefs::kHomePage, *expected);
+  int64 node_id = SetSyncedValue(prefs::kHomePage, *expected,
+                                 service_->GetUserShare());
   ASSERT_NE(node_id, syncer::kInvalidId);
   {
     syncer::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
     change_processor_->ApplyChangesFromSyncModel(
         &trans,
         ProfileSyncServiceTestHelper::MakeSingletonChangeRecordList(
             node_id, ChangeRecord::ACTION_UPDATE));
   }
   change_processor_->CommitChangesFromSyncModel();
 
   const Value& actual = GetPreferenceValue(prefs::kHomePage);
   EXPECT_TRUE(expected->Equals(&actual));
 }
 
 TEST_F(ProfileSyncServicePreferenceTest, UpdatedSyncNodeActionAdd) {
   CreateRootHelper create_root(this, syncer::PREFERENCES);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
 
   scoped_ptr<Value> expected(Value::CreateStringValue(example_url0_));
-  int64 node_id = SetSyncedValue(prefs::kHomePage, *expected);
+  int64 node_id = SetSyncedValue(prefs::kHomePage, *expected,
+        service_->GetUserShare());
   ASSERT_NE(node_id, syncer::kInvalidId);
   {
     syncer::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
     change_processor_->ApplyChangesFromSyncModel(
         &trans,
         ProfileSyncServiceTestHelper::MakeSingletonChangeRecordList(
             node_id, ChangeRecord::ACTION_ADD));
   }
   change_processor_->CommitChangesFromSyncModel();
 
   const Value& actual = GetPreferenceValue(prefs::kHomePage);
   EXPECT_TRUE(expected->Equals(&actual));
   EXPECT_EQ(1U,
       pref_sync_service_->registered_preferences().count(prefs::kHomePage));
 }
 
 TEST_F(ProfileSyncServicePreferenceTest, UpdatedSyncNodeUnknownPreference) {
   CreateRootHelper create_root(this, syncer::PREFERENCES);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
 
   scoped_ptr<Value> expected(Value::CreateStringValue(example_url0_));
-  int64 node_id = SetSyncedValue("unknown preference", *expected);
+  int64 node_id = SetSyncedValue("unknown preference", *expected,
+        service_->GetUserShare());
   ASSERT_NE(node_id, syncer::kInvalidId);
   {
     syncer::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
     change_processor_->ApplyChangesFromSyncModel(
         &trans,
         ProfileSyncServiceTestHelper::MakeSingletonChangeRecordList(
             node_id, ChangeRecord::ACTION_UPDATE));
   }
   change_processor_->CommitChangesFromSyncModel();
 
@@ skipping 14 matching lines @@
   // Changing the homepage preference should not sync anything.
   scoped_ptr<Value> user_value(
       Value::CreateStringValue("http://chromium..com"));
   prefs_->SetUserPref(prefs::kHomePage, user_value->DeepCopy());
   EXPECT_EQ(NULL, GetSyncedValue(prefs::kHomePage));
 
   // An incoming sync transaction should change the user value, not the managed
   // value.
   scoped_ptr<Value> sync_value(
       Value::CreateStringValue("http://crbug.com"));
-  int64 node_id = SetSyncedValue(prefs::kHomePage, *sync_value);
+  int64 node_id = SetSyncedValue(prefs::kHomePage, *sync_value,
+        service_->GetUserShare());
   ASSERT_NE(node_id, syncer::kInvalidId);
   {
     syncer::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
     change_processor_->ApplyChangesFromSyncModel(
         &trans,
         ProfileSyncServiceTestHelper::MakeSingletonChangeRecordList(
             node_id, ChangeRecord::ACTION_UPDATE));
   }
   change_processor_->CommitChangesFromSyncModel();
 
@@ skipping 42 matching lines @@
 
   // Switch kHomePage to managed and set a different value.
   scoped_ptr<Value> managed_value(
       Value::CreateStringValue("http://example.com/managed"));
   profile_->GetTestingPrefService()->SetManagedPref(
       prefs::kHomePage, managed_value->DeepCopy());
 
   // Change the sync value.
   scoped_ptr<Value> sync_value(
       Value::CreateStringValue("http://example.com/sync"));
-  int64 node_id = SetSyncedValue(prefs::kHomePage, *sync_value);
+  int64 node_id = SetSyncedValue(prefs::kHomePage, *sync_value,
+        service_->GetUserShare());
   ASSERT_NE(node_id, syncer::kInvalidId);
   {
     syncer::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
     change_processor_->ApplyChangesFromSyncModel(
         &trans,
         ProfileSyncServiceTestHelper::MakeSingletonChangeRecordList(
             node_id, ChangeRecord::ACTION_ADD));
   }
   change_processor_->CommitChangesFromSyncModel();
 
@@ skipping 27 matching lines @@
   EXPECT_FALSE(pref->IsDefaultValue());
   // There should be no synced value.
   EXPECT_TRUE(GetSyncedValue(prefs::kHomePage) == NULL);
   // Switch kHomePage back to unmanaged.
   profile_->GetTestingPrefService()->RemoveManagedPref(prefs::kHomePage);
   // The original value should be picked up.
   EXPECT_TRUE(pref->IsDefaultValue());
   // There should still be no synced value.
   EXPECT_TRUE(GetSyncedValue(prefs::kHomePage) == NULL);
 }