Fix some migration-related bugs

chrome/browser/sync/backend_migrator.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/backend_migrator.h"
 
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/tracked_objects.h"
 #include "chrome/browser/sync/internal_api/configure_reason.h"
@@ skipping 10 matching lines @@
 namespace browser_sync {
 
 using sessions::SyncSessionSnapshot;
 using syncable::ModelTypeToString;
 
 MigrationObserver::~MigrationObserver() {}
 
 BackendMigrator::BackendMigrator(const std::string& name,
                                  sync_api::UserShare* user_share,
                                  ProfileSyncService* service,
-                                 DataTypeManager* manager)
+                                 DataTypeManager* manager,
+                                 const base::Closure &migration_done_callback)
     : name_(name), user_share_(user_share), service_(service),
       manager_(manager), state_(IDLE),
-      weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
-  registrar_.Add(this, chrome::NOTIFICATION_SYNC_CONFIGURE_DONE,
-                 content::Source<DataTypeManager>(manager_));
+      weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      migration_done_callback_(migration_done_callback) {
 }
 
 BackendMigrator::~BackendMigrator() {
 }
 
 // Helper macros to log with the syncer thread name; useful when there
 // are multiple syncer threads involved.
 
 #define SLOG(severity) LOG(severity) << name_ << ": "
 
@@ skipping 66 matching lines @@
   // Add nigori for config or not based upon if the server told us to migrate
   // nigori or not.
   if (configure_with_nigori) {
     manager_->Configure(difference, sync_api::CONFIGURE_REASON_MIGRATION);
   } else {
     manager_->ConfigureWithoutNigori(difference,
                                      sync_api::CONFIGURE_REASON_MIGRATION);
   }
 }
 
-void BackendMigrator::Observe(int type,
-                              const content::NotificationSource& source,
-                              const content::NotificationDetails& details) {
-  DCHECK_EQ(chrome::NOTIFICATION_SYNC_CONFIGURE_DONE, type);
+void BackendMigrator::OnConfigureDone(
+    const DataTypeManager::ConfigureResult& result) {
   if (state_ == IDLE)
     return;
 
   // |manager_|'s methods aren't re-entrant, and we're notified from
   // them, so post a task to avoid problems.
-  SDVLOG(1) << "Posting OnConfigureDone from Observer";
+  SDVLOG(1) << "Posting OnConfigureDoneImpl";
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(&BackendMigrator::OnConfigureDone,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 *content::Details<DataTypeManager::ConfigureResult>(
-                     details).ptr()));
+      base::Bind(&BackendMigrator::OnConfigureDoneImpl,
+                 weak_ptr_factory_.GetWeakPtr(), result));
 }
 
 namespace {
 
 syncable::ModelTypeSet GetUnsyncedDataTypes(sync_api::UserShare* user_share) {
   sync_api::ReadTransaction trans(FROM_HERE, user_share);
   syncable::ModelTypeSet unsynced_data_types;
   for (int i = syncable::FIRST_REAL_MODEL_TYPE;
        i < syncable::MODEL_TYPE_COUNT; ++i) {
     syncable::ModelType type = syncable::ModelTypeFromInt(i);
     sync_pb::DataTypeProgressMarker progress_marker;
     trans.GetDirectory()->GetDownloadProgress(type, &progress_marker);
     if (progress_marker.token().empty()) {
       unsynced_data_types.Put(type);
     }
   }
   return unsynced_data_types;
 }
 
 }  // namespace
 
-void BackendMigrator::OnConfigureDone(
+void BackendMigrator::OnConfigureDoneImpl(
     const DataTypeManager::ConfigureResult& result) {
   SDVLOG(1) << "OnConfigureDone with requested types "
             << ModelTypeSetToString(result.requested_types)
             << ", status " << result.status
             << ", and to_migrate_ = " << ModelTypeSetToString(to_migrate_);
   if (state_ == WAITING_TO_START) {
     if (!TryStart())
       SDVLOG(1) << "Manager still not configured; still waiting";
     return;
   }
@@ skipping 43 matching lines @@
     SDVLOG(1) << "BackendMigrator re-enabling types: "
               << syncable::ModelTypeSetToString(full_set);
     manager_->Configure(full_set, sync_api::CONFIGURE_REASON_MIGRATION);
   } else if (state_ == REENABLING_TYPES) {
     // We're done!
     ChangeState(IDLE);
 
     SDVLOG(1) << "BackendMigrator: Migration complete for: "
               << syncable::ModelTypeSetToString(to_migrate_);
     to_migrate_.Clear();
+
+    if (!migration_done_callback_.is_null())
+      migration_done_callback_.Run();
   }
 }
 
 BackendMigrator::State BackendMigrator::state() const {
   return state_;
 }
 
 syncable::ModelTypeSet
     BackendMigrator::GetPendingMigrationTypesForTest() const {
   return to_migrate_;
 }
 
 #undef SDVLOG
 
 #undef SLOG
 
 };  // namespace browser_sync