Make SyncBackendRegistrar aware of loaded data

chrome/browser/sync/profile_sync_service_session_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 199 matching lines @@
     set_profile(NULL);
 
     // Pump messages posted by the sync core thread (which may end up
     // posting on the IO thread).
     MessageLoop::current()->RunAllPending();
     io_thread_.Stop();
     MessageLoop::current()->RunAllPending();
     BrowserWithTestWindowTest::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 (sync_service_.get())
       return false;
     SigninManager* signin = SigninManagerFactory::GetForProfile(profile());
     signin->SetAuthenticatedUsername("test_user");
     ProfileSyncComponentsFactoryMock* factory =
         new ProfileSyncComponentsFactoryMock();
     sync_service_.reset(new TestProfileSyncService(
         factory,
         profile(),
         signin,
@@ skipping 43 matching lines @@
  public:
   explicit CreateRootHelper(ProfileSyncServiceSessionTest* test)
       : ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
             base::Bind(&CreateRootHelper::CreateRootCallback,
                        base::Unretained(this), test))),
         success_(false) {
   }
 
   virtual ~CreateRootHelper() {}
 
-  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 CreateRootCallback(ProfileSyncServiceSessionTest* test) {
+  void CreateRootCallback(ProfileSyncServiceSessionTest* test,
+                          syncer::UserShare* user_share) {
     success_ = ProfileSyncServiceTestHelper::CreateRoot(
-        syncer::SESSIONS, test->sync_service()->GetUserShare(), test->ids());
+        syncer::SESSIONS, user_share, test->ids());
   }
 
-  base::Closure callback_;
+  base::Callback<void(syncer::UserShare*)> callback_;
   bool success_;
 };
 
 // Test that we can write this machine's session to a node and retrieve it.
 TEST_F(ProfileSyncServiceSessionTest, WriteSessionToNode) {
   CreateRootHelper create_root(this);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
 
   // Check that the DataTypeController associated the models.
@@ skipping 61 matching lines @@
   iter++;
   ASSERT_EQ(2, iter->second->tab()->GetEntryCount());
   ASSERT_EQ(GURL("http://bar/1"), iter->second->tab()->
       GetEntryAtIndex(0)->GetVirtualURL());
   ASSERT_EQ(GURL("http://bar/2"), iter->second->tab()->
       GetEntryAtIndex(1)->GetVirtualURL());
 }
 
 // Test that we fail on a failed model association.
 TEST_F(ProfileSyncServiceSessionTest, FailModelAssociation) {
-  ASSERT_TRUE(StartSyncService(base::Closure(), true));
+  ASSERT_TRUE(StartSyncService(
+          TestProfileSyncService::NullCallback(), true));
   ASSERT_TRUE(sync_service_->HasUnrecoverableError());
 }
 
 // Write a foreign session to a node, and then retrieve it.
 TEST_F(ProfileSyncServiceSessionTest, WriteForeignSessionToNode) {
   CreateRootHelper create_root(this);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
 
   // Check that the DataTypeController associated the models.
@@ skipping 808 matching lines @@
     sync_pb::SessionSpecifics specifics;
     header.SetSessionSpecifics(specifics);
   }
   // Ensure we associate properly despite the pre-existing node with our local
   // tag.
   error = model_associator_->AssociateModels();
   ASSERT_FALSE(error.IsSet());
 }
 
 }  // namespace browser_sync