[Sync] Make BackendMigrator not wait for full sync cycles

chrome/browser/sync/profile_sync_service.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/profile_sync_service.h"
 
 #include <stddef.h>
 #include <map>
 #include <set>
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string16.h"
 #include "base/stringprintf.h"
 #include "base/task.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/about_flags.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/net/chrome_cookie_notification_details.h"
 #include "chrome/browser/net/gaia/token_service.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/sync/backend_migrator.h"
 #include "chrome/browser/sync/glue/change_processor.h"
 #include "chrome/browser/sync/glue/data_type_controller.h"
 #include "chrome/browser/sync/glue/session_data_type_controller.h"
 #include "chrome/browser/sync/glue/typed_url_data_type_controller.h"
 #include "chrome/browser/sync/glue/data_type_manager.h"
 #include "chrome/browser/sync/glue/session_data_type_controller.h"
 #include "chrome/browser/sync/internal_api/configure_reason.h"
 #include "chrome/browser/sync/internal_api/sync_manager.h"
 #include "chrome/browser/sync/js/js_arg_list.h"
 #include "chrome/browser/sync/js/js_event_details.h"
@@ skipping 345 matching lines @@
   backend_->Initialize(
       this,
       WeakHandle<JsEventHandler>(sync_js_controller_.AsWeakPtr()),
       sync_service_url_,
       initial_types,
       credentials,
       delete_sync_data_folder);
 }
 
 void ProfileSyncService::CreateBackend() {
-  backend_.reset(new SyncBackendHost(profile_));
+  backend_.reset(new SyncBackendHost(profile_->GetDebugName(), profile_));
 }
 
 bool ProfileSyncService::IsEncryptedDatatypeEnabled() const {
   if (HasPendingEncryptedTypes())
     return true;
   syncable::ModelTypeSet preferred_types;
   GetPreferredDataTypes(&preferred_types);
   syncable::ModelTypeSet encrypted_types;
   GetEncryptedDataTypes(&encrypted_types);
   syncable::ModelTypeBitSet preferred_types_bitset =
@@ skipping 35 matching lines @@
                       chrome::NOTIFICATION_SYNC_CONFIGURE_START,
                       Source<DataTypeManager>(data_type_manager_.get()));
     registrar_.Remove(this,
                       chrome::NOTIFICATION_SYNC_CONFIGURE_DONE,
                       Source<DataTypeManager>(data_type_manager_.get()));
     data_type_manager_.reset();
   }
 
   // Shutdown the migrator before the backend to ensure it doesn't pull a null
   // snapshot.
+  if (migrator_.get()) {
+    migrator_->RemoveMigrationObserver(this);

[tim (not reviewing), 2011/09/01 01:50:56]

hm, I thought we discussed just having the harness watch migration so it can
test it...  not sure why the service needs to do this

[akalin, 2011/09/01 02:19:40]

Okay, I guess that requires plumbing the migrator up to PSS, or at least the
Add/RemoveMigrationObserver() methods.  I can do that.

[akalin, 2011/09/01 03:39:50]

Exposed migrator via GetBackendMigratorForTest().

+  }
   migrator_.reset();
   sync_js_controller_.AttachJsBackend(WeakHandle<JsBackend>());
 
   // Move aside the backend so nobody else tries to use it while we are
   // shutting it down.
   scoped_ptr<SyncBackendHost> doomed_backend(backend_.release());
   if (doomed_backend.get()) {
     doomed_backend->Shutdown(sync_disabled);
 
     doomed_backend.reset();
@@ skipping 136 matching lines @@
   unrecoverable_error_location_.reset(
       new tracked_objects::Location(from_here.function_name(),
                                     from_here.file_name(),
                                     from_here.line_number(),
                                     from_here.program_counter()));
 
   // Tell the wizard so it can inform the user only if it is already open.
   wizard_.Step(SyncSetupWizard::FATAL_ERROR);
 
   NotifyObservers();
-  LOG(ERROR) << "Unrecoverable error detected -- ProfileSyncService unusable."
-      << message;
   std::string location;
   from_here.Write(true, true, &location);
-  LOG(ERROR) << location;
+  LOG(ERROR)
+      << "Unrecoverable error detected at " << location
+      << " -- ProfileSyncService unusable: " << message;
 
   // Shut all data types down.
   MessageLoop::current()->PostTask(FROM_HERE,
         scoped_runnable_method_factory_.NewRunnableMethod(
         &ProfileSyncService::Shutdown, true));
 }
 
+void ProfileSyncService::OnMigrationStateChange() {
+  // Needed by migration integration tests.
+  NotifyObservers();
+}
+
 void ProfileSyncService::OnBackendInitialized(
     const WeakHandle<JsBackend>& js_backend, bool success) {
   if (!success) {
     // If backend initialization failed, abort.  We only want to blow away
     // state (DBs, etc) if this was a first-time scenario that failed.
     wizard_.Step(SyncSetupWizard::FATAL_ERROR);
     Shutdown(!HasSyncSetupCompleted());
     return;
   }
 
@@ skipping 591 matching lines @@
                                         &data_type_controllers_));
     registrar_.Add(this,
                    chrome::NOTIFICATION_SYNC_CONFIGURE_START,
                    Source<DataTypeManager>(data_type_manager_.get()));
     registrar_.Add(this,
                    chrome::NOTIFICATION_SYNC_CONFIGURE_DONE,
                    Source<DataTypeManager>(data_type_manager_.get()));
 
     // We create the migrator at the same time.
     migrator_.reset(
-        new browser_sync::BackendMigrator(this, data_type_manager_.get()));
+        new browser_sync::BackendMigrator(
+            profile_->GetDebugName(), GetUserShare(),
+            this, data_type_manager_.get()));
+    migrator_->AddMigrationObserver(this);
   }
 
   syncable::ModelTypeSet types;
   GetPreferredDataTypes(&types);
   if (IsPassphraseRequiredForDecryption()) {
     if (IsEncryptedDatatypeEnabled()) {
       // We need a passphrase still. We don't bother to attempt to configure
       // until we receive an OnPassphraseAccepted (which triggers a configure).
       VLOG(1) << "ProfileSyncService::ConfigureDataTypeManager bailing out "
               << "because a passphrase required";
@@ skipping 53 matching lines @@
   }
   VLOG(level) << "Unsynced items not printed because backend is not "
               << "initialized";
 }
 
 bool ProfileSyncService::HasPendingBackendMigration() const {
   return migrator_.get() &&
       migrator_->state() != browser_sync::BackendMigrator::IDLE;
 }
 
+syncable::ModelTypeSet
+    ProfileSyncService::GetPendingMigrationTypesForTest() const {
+  return
+      migrator_.get() ?
+      migrator_->GetPendingMigrationTypesForTest() :
+      syncable::ModelTypeSet();
+}
+
 void ProfileSyncService::GetModelSafeRoutingInfo(
     browser_sync::ModelSafeRoutingInfo* out) const {
   if (backend_.get() && backend_initialized_) {
     backend_->GetModelSafeRoutingInfo(out);
   } else {
     NOTREACHED();
   }
 }
 
 void ProfileSyncService::ActivateDataType(
@@ skipping 260 matching lines @@
             *profile_->GetPrefs()->GetList(prefs::kAcknowledgedSyncTypes));
     syncable::ModelTypeSet registered;
     GetRegisteredDataTypes(&registered);
     syncable::ModelTypeBitSet registered_bit_set =
         syncable::ModelTypeBitSetFromSet(registered);
     unacknowledged = registered_bit_set & ~acknowledged;
   }
   return unacknowledged;
 }