Make SyncBackendRegistrar aware of loaded data

chrome/browser/sync/profile_sync_service_autofill_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 <set>
 #include <string>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 380 matching lines @@
     // Note: The tear down order is important.
     service_.reset();
     web_data_service_->ShutdownSyncableService();
     profile_->ResetRequestContext();
     // To prevent a leak, fully release TestURLRequestContext to ensure its
     // destruction on the IO message loop.
     profile_.reset();
     AbstractProfileSyncServiceTest::TearDown();
   }
 
-  void StartSyncService(const base::Closure& callback,
-                        bool will_fail_association,
-                        syncer::ModelType type) {
+  void StartSyncService(
+      const base::Callback<void(syncer::UserShare*)>& callback,
+      bool will_fail_association,
+      syncer::ModelType type) {
     AbstractAutofillFactory* factory = GetFactory(type);
     SigninManager* signin = SigninManagerFactory::GetForProfile(profile_.get());
     signin->SetAuthenticatedUsername("test_user");
     ProfileSyncComponentsFactoryMock* components_factory =
         new ProfileSyncComponentsFactoryMock();
     service_.reset(
         new TestProfileSyncService(components_factory,
                                    profile_.get(),
                                    signin,
                                    ProfileSyncService::AUTO_START,
@@ skipping 16 matching lines @@
         WillRepeatedly(Return(true));
 
      // We need tokens to get the tests going
     token_service_->IssueAuthTokenForTest(GaiaConstants::kSyncService, "token");
 
     service_->RegisterDataTypeController(data_type_controller);
     service_->Initialize();
     MessageLoop::current()->Run();
   }
 
-  bool AddAutofillSyncNode(const AutofillEntry& entry) {
-    syncer::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
+  bool AddAutofillSyncNode(
+      const AutofillEntry& entry,
+      syncer::UserShare* user_share) {
+    syncer::WriteTransaction trans(FROM_HERE, user_share);
     syncer::ReadNode autofill_root(&trans);
     if (autofill_root.InitByTagLookup(
             syncer::ModelTypeToRootTag(syncer::AUTOFILL)) !=
                 BaseNode::INIT_OK) {
       return false;
     }
 
     syncer::WriteNode node(&trans);
     std::string tag = AutocompleteSyncableService::KeyToTag(
         UTF16ToUTF8(entry.key().name()), UTF16ToUTF8(entry.key().value()));
     syncer::WriteNode::InitUniqueByCreationResult result =
         node.InitUniqueByCreation(syncer::AUTOFILL, autofill_root, tag);
     if (result != syncer::WriteNode::INIT_SUCCESS)
       return false;
 
     sync_pb::EntitySpecifics specifics;
     AutocompleteSyncableService::WriteAutofillEntry(entry, &specifics);
     sync_pb::AutofillSpecifics* autofill_specifics =
         specifics.mutable_autofill();
     node.SetAutofillSpecifics(*autofill_specifics);
     return true;
   }
 
-  bool AddAutofillSyncNode(const AutofillProfile& profile) {
-    syncer::WriteTransaction trans(FROM_HERE, service_->GetUserShare());
+  bool AddAutofillSyncNode(const AutofillProfile& profile,
+                           syncer::UserShare* user_share) {
+    syncer::WriteTransaction trans(FROM_HERE, user_share);
     syncer::ReadNode autofill_root(&trans);
     if (autofill_root.InitByTagLookup(kAutofillProfileTag) !=
             BaseNode::INIT_OK) {
       return false;
     }
     syncer::WriteNode node(&trans);
     std::string tag = profile.guid();
     syncer::WriteNode::InitUniqueByCreationResult result =
         node.InitUniqueByCreation(syncer::AUTOFILL_PROFILE,
                                   autofill_root, tag);
@@ skipping 119 matching lines @@
 class AddAutofillHelper {
  public:
   AddAutofillHelper(ProfileSyncServiceAutofillTest* test,
                     const std::vector<T>& entries)
       : ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
           base::Bind(&AddAutofillHelper::AddAutofillCallback,
                      base::Unretained(this), test, entries))),
         success_(false) {
   }
 
-  const base::Closure& callback() const { return callback_; }
-  bool success() { return success_; }
+  const base::Callback<void(syncer::UserShare* user_share)>& callback() const {
+    return callback_;
+  }
+
+  bool success() {
+    return success_;
+  }
 
  private:
   void AddAutofillCallback(ProfileSyncServiceAutofillTest* test,
-                           const std::vector<T>& entries) {
-    if (!test->CreateRoot(GetModelType<T>()))
+                           const std::vector<T>& entries,
+                           syncer::UserShare* user_share) {
+    if (!test->CreateRoot(GetModelType<T>(), user_share))
       return;
 
     for (size_t i = 0; i < entries.size(); ++i) {
-      if (!test->AddAutofillSyncNode(entries[i]))
+      if (!test->AddAutofillSyncNode(entries[i], user_share))
         return;
     }
     success_ = true;
   }
 
-  base::Closure callback_;
+  base::Callback<void(syncer::UserShare* user_share)> callback_;
   bool success_;
 };
 
 // Overload write transaction to use custom NotifyTransactionComplete
 class WriteTransactionTest: public WriteTransaction {
  public:
   WriteTransactionTest(const tracked_objects::Location& from_here,
                        WriterTag writer,
                        syncer::syncable::Directory* directory,
                        scoped_ptr<WaitableEvent>* wait_for_syncapi)
@@ skipping 132 matching lines @@
 }
 
 };
 
 // TODO(skrul): Test abort startup.
 // TODO(skrul): Test processing of cloud changes.
 // TODO(tim): Add autofill data type controller test, and a case to cover
 //            waiting for the PersonalDataManager.
 TEST_F(ProfileSyncServiceAutofillTest, FailModelAssociation) {
   // Don't create the root autofill node so startup fails.
-  StartSyncService(base::Closure(), true, syncer::AUTOFILL);
+  StartSyncService(TestProfileSyncService::NullCallback(), true,
+                   syncer::AUTOFILL);
   EXPECT_TRUE(service_->HasUnrecoverableError());
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, EmptyNativeEmptySync) {
   EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).WillOnce(Return(true));
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, syncer::AUTOFILL);
   EXPECT_CALL(*personal_data_manager_, Refresh());
   StartSyncService(create_root.callback(), false, syncer::AUTOFILL);
   EXPECT_TRUE(create_root.success());
@@ skipping 441 matching lines @@
   scoped_ptr<WaitableEvent> wait_for_start(new WaitableEvent(true, false));
   scoped_ptr<WaitableEvent> wait_for_syncapi(new WaitableEvent(true, false));
   scoped_refptr<FakeServerUpdater> updater(new FakeServerUpdater(
       service_.get(), &wait_for_start, &wait_for_syncapi));
 
   // This server side update will stall waiting for CommitWaiter.
   updater->CreateNewEntry(MakeAutofillEntry("server", "entry", 1));
   wait_for_start->Wait();
 
   AutofillEntry syncapi_entry(MakeAutofillEntry("syncapi", "entry", 2));
-  ASSERT_TRUE(AddAutofillSyncNode(syncapi_entry));
+  ASSERT_TRUE(AddAutofillSyncNode(syncapi_entry, service_->GetUserShare()));
   DVLOG(1) << "Syncapi update finished.";
 
   // If we reach here, it means syncapi succeeded and we didn't deadlock. Yay!
   // Signal FakeServerUpdater that it can complete.
   wait_for_syncapi->Signal();
 
   // Make another entry to ensure nothing broke afterwards and wait for finish
   // to clean up.
   updater->CreateNewEntryAndWait(MakeAutofillEntry("server2", "entry2", 3));
 
   std::vector<AutofillEntry> sync_entries;
   std::vector<AutofillProfile> sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&sync_entries, &sync_profiles));
   EXPECT_EQ(3U, sync_entries.size());
   EXPECT_EQ(0U, sync_profiles.size());
   for (size_t i = 0; i < sync_entries.size(); i++) {
     DVLOG(1) << "Entry " << i << ": " << sync_entries[i].key().name()
              << ", " << sync_entries[i].key().value();
   }
 }