[Sync] Make BackendMigrator not wait for full sync cycles

chrome/browser/sync/internal_api/sync_manager.cc

 // Copyright (c) 2011 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/internal_api/sync_manager.h"
 
 #include <string>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 660 matching lines @@
 
 void SyncManager::EncryptDataTypes(
     const syncable::ModelTypeSet& encrypted_types) {
   data_->EncryptDataTypes(encrypted_types);
 }
 
 bool SyncManager::IsUsingExplicitPassphrase() {
   return data_ && data_->IsUsingExplicitPassphrase();
 }
 
-void SyncManager::RequestCleanupDisabledTypes() {
+void SyncManager::RequestCleanupDisabledTypes(const base::Closure& callback) {
   if (data_->scheduler())
-    data_->scheduler()->ScheduleCleanupDisabledTypes();
+    data_->scheduler()->ScheduleCleanupDisabledTypes(callback);
 }
 
 void SyncManager::RequestClearServerData() {
   if (data_->scheduler())
     data_->scheduler()->ScheduleClearUserData();
 }
 
 void SyncManager::RequestConfig(const syncable::ModelTypeBitSet& types,
     ConfigureReason reason) {
   if (!data_->scheduler()) {
     LOG(INFO)
         << "SyncManager::RequestConfig: bailing out because scheduler is "
         << "null";
     return;
   }
-  StartConfigurationMode(NULL);
+  StartConfigurationMode(base::Closure());
   data_->scheduler()->ScheduleConfig(types, reason);
 }
 
-void SyncManager::StartConfigurationMode(ModeChangeCallback* callback) {
+void SyncManager::StartConfigurationMode(const base::Closure& callback) {
   if (!data_->scheduler()) {
     LOG(INFO)
         << "SyncManager::StartConfigurationMode: could not start "
         << "configuration mode because because scheduler is null";
     return;
   }
   data_->scheduler()->Start(
       browser_sync::SyncScheduler::CONFIGURATION_MODE, callback);
 }
 
@@ skipping 61 matching lines @@
         listeners);
     context->set_account_name(credentials.email);
     // The SyncScheduler takes ownership of |context|.
     scheduler_.reset(new SyncScheduler(name_, context, new Syncer()));
   }
 
   bool signed_in = SignIn(credentials);
 
   if (signed_in && scheduler()) {
     scheduler()->Start(
-        browser_sync::SyncScheduler::CONFIGURATION_MODE, NULL);
+        browser_sync::SyncScheduler::CONFIGURATION_MODE, base::Closure());
   }
 
   initialized_ = true;
 
   // Notify that initialization is complete.
   ObserverList<SyncManager::Observer> temp_obs_list;
   CopyObservers(&temp_obs_list);
   FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
                     OnInitializationComplete(
                         WeakHandle<JsBackend>(weak_ptr_factory_.GetWeakPtr())));
@@ skipping 49 matching lines @@
   allstatus_.SetCryptoHasPendingKeys(cryptographer->has_pending_keys());
 
   return cryptographer->is_ready();
 }
 
 void SyncManager::SyncInternal::StartSyncingNormally() {
   // Start the sync scheduler. This won't actually result in any
   // syncing until at least the DirectoryManager broadcasts the OPENED
   // event, and a valid server connection is detected.
   if (scheduler())  // NULL during certain unittests.
-    scheduler()->Start(SyncScheduler::NORMAL_MODE, NULL);
+    scheduler()->Start(SyncScheduler::NORMAL_MODE, base::Closure());
 }
 
 bool SyncManager::SyncInternal::OpenDirectory() {
   DCHECK(!initialized_) << "Should only happen once";
 
   bool share_opened = dir_manager()->Open(username_for_share(), this);
   DCHECK(share_opened);
   if (!share_opened) {
     ObserverList<SyncManager::Observer> temp_obs_list;
     CopyObservers(&temp_obs_list);
@@ skipping 1188 matching lines @@
 
   for (syncable::ModelTypeSet::const_iterator i = types.begin();
        i != types.end(); ++i) {
     if (!lookup->initial_sync_ended_for_type(*i))
       return false;
   }
   return true;
 }
 
 }  // namespace sync_api