Make SyncBackendRegistrar aware of loaded data

chrome/browser/sync/test_profile_sync_service.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/test_profile_sync_service.h"
 
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/sync/abstract_profile_sync_service_test.h"
 #include "chrome/browser/sync/glue/data_type_controller.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
@@ skipping 14 matching lines @@
 using syncer::sessions::SyncSourceInfo;
 using syncer::UserShare;
 using syncer::syncable::Directory;
 
 namespace browser_sync {
 
 SyncBackendHostForProfileSyncTest::SyncBackendHostForProfileSyncTest(
     Profile* profile,
     const base::WeakPtr<SyncPrefs>& sync_prefs,
     const base::WeakPtr<InvalidatorStorage>& invalidator_storage,
+    syncer::TestIdFactory& id_factory,
+    base::Closure& callback,
     bool set_initial_sync_ended_on_init,
     bool synchronous_init,
     bool fail_initial_download,
     bool use_real_database)
     : browser_sync::SyncBackendHost(
         profile->GetDebugName(), profile, sync_prefs, invalidator_storage),
+      id_factory_(id_factory),
+      callback_(callback),
+      set_initial_sync_ended_on_init_(set_initial_sync_ended_on_init),
       synchronous_init_(synchronous_init),
       fail_initial_download_(fail_initial_download),
       use_real_database_(use_real_database) {}
 
 SyncBackendHostForProfileSyncTest::~SyncBackendHostForProfileSyncTest() {}
 
 namespace {
 
 scoped_ptr<syncer::HttpPostProviderFactory> MakeTestHttpBridgeFactory() {
   return scoped_ptr<syncer::HttpPostProviderFactory>(
@@ skipping 37 matching lines @@
     const base::Closure& retry_callback) {
   syncer::ModelTypeSet sync_ended;
   if (!fail_initial_download_)
     sync_ended.PutAll(types_to_config);
 
   FinishConfigureDataTypesOnFrontendLoop(types_to_config,
                                          sync_ended,
                                          ready_task);
 }
 
+void SyncBackendHostForProfileSyncTest
+        ::HandleSyncManagerInitializationOnFrontendLoop(
+    const syncer::WeakHandle<syncer::JsBackend>& js_backend, bool success,
+    syncer::ModelTypeSet restored_types) {
+  // Here's our opportunity to pretend to do things that the SyncManager would
+  // normally do during initialization, but can't because this is a test.
+  bool send_passphrase_required = false;
+  if (success) {
+    // Set up any nodes the test wants around before model association.
+    if (!callback_.is_null()) {
+      callback_.Run();
+    }
+
+    // Pretend we downloaded initial updates and set initial sync ended bits
+    // if we were asked to.
+    if (set_initial_sync_ended_on_init_) {
+      UserShare* user_share = GetUserShare();
+      Directory* directory = user_share->directory.get();
+
+      if (!directory->initial_sync_ended_for_type(syncer::NIGORI)) {
+        ProfileSyncServiceTestHelper::CreateRoot(
+            syncer::NIGORI, user_share, &id_factory_);
+
+        // A side effect of adding the NIGORI mode (normally done by the
+        // syncer) is a decryption attempt, which will fail the first time.
+        send_passphrase_required = true;
+      }
+
+      SetInitialSyncEndedForAllTypes();
+      restored_types = syncer::ModelTypeSet::All();
+    }
+  }
+
+  SyncBackendHost::HandleSyncManagerInitializationOnFrontendLoop(
+      js_backend, success, restored_types);
+}
+
+void SyncBackendHostForProfileSyncTest::SetInitialSyncEndedForAllTypes() {
+  UserShare* user_share = GetUserShare();
+  Directory* directory = user_share->directory.get();
+
+  for (int i = syncer::FIRST_REAL_MODEL_TYPE;
+       i < syncer::MODEL_TYPE_COUNT; ++i) {
+    directory->set_initial_sync_ended_for_type(
+        syncer::ModelTypeFromInt(i), true);
+  }
+}
+
 }  // namespace browser_sync
 
 syncer::TestIdFactory* TestProfileSyncService::id_factory() {
   return &id_factory_;
 }
 
 browser_sync::SyncBackendHostForProfileSyncTest*
     TestProfileSyncService::GetBackendForTest() {
   return static_cast<browser_sync::SyncBackendHostForProfileSyncTest*>(
       ProfileSyncService::GetBackendForTest());
@@ skipping 16 matching lines @@
       callback_(callback),
       set_initial_sync_ended_on_init_(true),
       fail_initial_download_(false),
       use_real_database_(false) {
   SetSyncSetupCompleted();
 }
 
 TestProfileSyncService::~TestProfileSyncService() {
 }
 
-void TestProfileSyncService::SetInitialSyncEndedForAllTypes() {
-  UserShare* user_share = GetUserShare();
-  Directory* directory = user_share->directory.get();
-
-  for (int i = syncer::FIRST_REAL_MODEL_TYPE;
-       i < syncer::MODEL_TYPE_COUNT; ++i) {
-    directory->set_initial_sync_ended_for_type(
-        syncer::ModelTypeFromInt(i), true);
-  }
-}
-
 void TestProfileSyncService::OnBackendInitialized(
     const syncer::WeakHandle<syncer::JsBackend>& backend,
     bool success) {
-  bool send_passphrase_required = false;
-  if (success) {
-    // Set this so below code can access GetUserShare().
-    backend_initialized_ = true;
-
-    // Set up any nodes the test wants around before model association.
-    if (!callback_.is_null()) {
-      callback_.Run();
-      callback_.Reset();
-    }
-
-    // Pretend we downloaded initial updates and set initial sync ended bits
-    // if we were asked to.
-    if (set_initial_sync_ended_on_init_) {
-      UserShare* user_share = GetUserShare();
-      Directory* directory = user_share->directory.get();
-
-      if (!directory->initial_sync_ended_for_type(syncer::NIGORI)) {
-        ProfileSyncServiceTestHelper::CreateRoot(
-            syncer::NIGORI, GetUserShare(),
-            id_factory());
-
-        // A side effect of adding the NIGORI mode (normally done by the
-        // syncer) is a decryption attempt, which will fail the first time.
-        send_passphrase_required = true;
-      }
-
-      SetInitialSyncEndedForAllTypes();
-    }
-  }
-
   ProfileSyncService::OnBackendInitialized(backend, success);
-  if (success && send_passphrase_required)
-    OnPassphraseRequired(syncer::REASON_DECRYPTION, sync_pb::EncryptedData());
 
   // TODO(akalin): Figure out a better way to do this.
   if (synchronous_backend_initialization_) {
     MessageLoop::current()->Quit();
   }
 }
 
 void TestProfileSyncService::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   ProfileSyncService::Observe(type, source, details);
   if (type == chrome::NOTIFICATION_SYNC_CONFIGURE_DONE &&
       !synchronous_sync_configuration_) {
     MessageLoop::current()->Quit();
   }
 }
 
+UserShare* TestProfileSyncService::GetUserShare() const {
+  return backend_->GetUserShare();
+}
+
 void TestProfileSyncService::dont_set_initial_sync_ended_on_init() {
   set_initial_sync_ended_on_init_ = false;
 }
 void TestProfileSyncService::set_synchronous_sync_configuration() {
   synchronous_sync_configuration_ = true;
 }
 void TestProfileSyncService::fail_initial_download() {
   fail_initial_download_ = true;
 }
 void TestProfileSyncService::set_use_real_database() {
   use_real_database_ = true;
 }
 
 void TestProfileSyncService::CreateBackend() {
   backend_.reset(new browser_sync::SyncBackendHostForProfileSyncTest(
       profile(),
       sync_prefs_.AsWeakPtr(),
       invalidator_storage_.AsWeakPtr(),
+      id_factory_,
+      callback_,
       set_initial_sync_ended_on_init_,
       synchronous_backend_initialization_,
       fail_initial_download_,
       use_real_database_));
 }