[Sync] Make BackendMigrator not wait for full sync cycles

chrome/browser/sync/glue/sync_backend_host.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 "build/build_config.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 48 matching lines @@
 using sessions::SyncSessionSnapshot;
 using sync_api::SyncCredentials;
 
 SyncBackendHost::SyncBackendHost(Profile* profile)
     : core_(new Core(profile,
                      ALLOW_THIS_IN_INITIALIZER_LIST(this))),
       initialization_state_(NOT_INITIALIZED),
       sync_thread_("Chrome_SyncThread"),
       frontend_loop_(MessageLoop::current()),
       profile_(profile),
+      name_(profile_->GetDebugName()),
       sync_notifier_factory_(webkit_glue::GetUserAgent(GURL()),
                              profile_->GetRequestContext(),
                              *CommandLine::ForCurrentProcess()),
       frontend_(NULL),
       sync_data_folder_path_(
           profile_->GetPath().Append(kSyncDataFolderName)),
       last_auth_error_(AuthError::None()) {
 }
 
 SyncBackendHost::SyncBackendHost()
@@ skipping 234 matching lines @@
       (*routing_info)[type] = GROUP_PASSIVE;
       state->added_types.insert(type);
     }
   }
 
   for (syncable::ModelTypeSet::const_iterator it = types_to_remove.begin();
        it != types_to_remove.end(); ++it) {
     routing_info->erase(*it);
   }
 
+  VLOG(1) << "Adding types " << syncable::ModelTypeSetToString(types_to_add)
+          << " and removing types "
+          << syncable::ModelTypeSetToString(types_to_remove)
+          << " to get new routing info "
+          << ModelSafeRoutingInfoToString(*routing_info);
+
   state->ready_task = ready_task;
   state->types_to_add = types_to_add;
   state->reason = reason;
 }
 
 void SyncBackendHost::ConfigureDataTypes(
     const syncable::ModelTypeSet& types_to_add,
     const syncable::ModelTypeSet& types_to_remove,
     sync_api::ConfigureReason reason,
     base::Callback<void(bool)> ready_task,
@@ skipping 69 matching lines @@
     // TODO(tim): If no added types, we could (should?) config only for
     // types that are needed... but this is a rare corruption edge case or
     // implies the user mucked around with their syncdb, so for now do all.
     pending_config_mode_state_->added_types =
         pending_config_mode_state_->types_to_add;
   }
 
   // If we've added types, we always want to request a nudge/config (even if
   // the initial sync is ended), in case we could not decrypt the data.
   if (pending_config_mode_state_->added_types.empty()) {
-    VLOG(1) << "SyncBackendHost(" << this << "): No new types added. "
-            << "Calling ready_task directly";
+    VLOG(1) << name_ << ": No new types added; calling ready_task directly";
     // No new types - just notify the caller that the types are available.
     pending_config_mode_state_->ready_task.Run(true);
   } else {
     pending_download_state_.reset(pending_config_mode_state_.release());
 
     // Always configure nigori if it's enabled.
     syncable::ModelTypeSet types_to_config =
         pending_download_state_->added_types;
     if (IsNigoriEnabled()) {
       types_to_config.insert(syncable::NIGORI);
     }
-    VLOG(1) <<  "SyncBackendHost(" << this << "):New Types added. "
-            << "Calling DoRequestConfig";
+    VLOG(1) << name_ << ": types " << ModelTypeSetToString(types_to_config)
+            << "added; calling DoRequestConfig";
     sync_thread_.message_loop()->PostTask(FROM_HERE,
          NewRunnableMethod(core_.get(),
                            &SyncBackendHost::Core::DoRequestConfig,
                            syncable::ModelTypeBitSetFromSet(types_to_config),
                            pending_download_state_->reason));
   }
 
   pending_config_mode_state_.reset();
 
   // Notify the SyncManager about the new types.
@@ skipping 432 matching lines @@
 
   // If we are waiting for a configuration change, check here to see
   // if this sync cycle has initialized all of the types we've been
   // waiting for.
   if (host_->pending_download_state_.get()) {
     scoped_ptr<PendingConfigureDataTypesState> state(
         host_->pending_download_state_.release());
     DCHECK(
         std::includes(state->types_to_add.begin(), state->types_to_add.end(),
                       state->added_types.begin(), state->added_types.end()));
+    VLOG(1)
+        << "Added types: "
+        << syncable::ModelTypeSetToString(state->added_types)
+        << ", configured types: "
+        << syncable::ModelTypeBitSetToString(snapshot->initial_sync_ended);
     syncable::ModelTypeBitSet added_types =
         syncable::ModelTypeBitSetFromSet(state->added_types);
     bool found_all_added =
         (added_types & snapshot->initial_sync_ended) == added_types;
     state->ready_task.Run(found_all_added);
     if (!found_all_added)
       return;
   }
 
   if (host_->initialized())
@@ skipping 172 matching lines @@
 }
 
 void SyncBackendHost::Core::DeleteSyncDataFolder() {
   if (file_util::DirectoryExists(host_->sync_data_folder_path())) {
     if (!file_util::Delete(host_->sync_data_folder_path(), true))
       LOG(DFATAL) << "Could not delete the Sync Data folder.";
   }
 }
 
 }  // namespace browser_sync