sync: Introduce control data types

chrome/browser/sync/backend_migrator_unittest.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/tracked_objects.h"
 #include "chrome/browser/sync/glue/data_type_manager_mock.h"
 #include "chrome/browser/sync/profile_sync_service_mock.h"
@@ skipping 112 matching lines @@
   migrator()->AddMigrationObserver(&migration_observer);
   EXPECT_CALL(migration_observer, OnMigrationStateChange()).Times(4);
 
   syncer::ModelTypeSet to_migrate, difference;
   to_migrate.Put(syncer::PREFERENCES);
   difference.Put(syncer::AUTOFILL);
   difference.Put(syncer::BOOKMARKS);
 
   EXPECT_CALL(*manager(), state())
       .WillOnce(Return(DataTypeManager::CONFIGURED));
-  EXPECT_CALL(*manager(), Configure(_, syncer::CONFIGURE_REASON_MIGRATION))
-      .Times(2);
+  EXPECT_CALL(
+      *manager(),
+      PurgeForMigration(_, syncer::CONFIGURE_REASON_MIGRATION)).Times(1);
+  EXPECT_CALL(
+      *manager(),
+      Configure(_, syncer::CONFIGURE_REASON_MIGRATION)).Times(1);
 
   migrator()->MigrateTypes(to_migrate);
   EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state());
 
   SetUnsyncedTypes(to_migrate);
   SendConfigureDone(DataTypeManager::OK, difference);
   EXPECT_EQ(BackendMigrator::REENABLING_TYPES, migrator()->state());
 
   SetUnsyncedTypes(syncer::ModelTypeSet());
   SendConfigureDone(DataTypeManager::OK, preferred_types());
   EXPECT_EQ(BackendMigrator::IDLE, migrator()->state());
 
   migrator()->RemoveMigrationObserver(&migration_observer);
 }
 
 // Test that in the normal case with Nigori a migration transitions through
 // each state and wind up back in IDLE.
 TEST_F(SyncBackendMigratorTest, MigrateNigori) {
   syncer::ModelTypeSet to_migrate, difference;
   to_migrate.Put(syncer::NIGORI);
   difference.Put(syncer::AUTOFILL);
   difference.Put(syncer::BOOKMARKS);
 
   EXPECT_CALL(*manager(), state())
       .WillOnce(Return(DataTypeManager::CONFIGURED));
 
-  EXPECT_CALL(*manager(), ConfigureWithoutNigori(_,
+  EXPECT_CALL(*manager(), PurgeForMigration(_,
       syncer::CONFIGURE_REASON_MIGRATION));
 
   migrator()->MigrateTypes(to_migrate);
   EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state());
 
   SetUnsyncedTypes(to_migrate);
   SendConfigureDone(DataTypeManager::OK, difference);
   EXPECT_EQ(BackendMigrator::REENABLING_TYPES, migrator()->state());
 
   SetUnsyncedTypes(syncer::ModelTypeSet());
@@ skipping 10 matching lines @@
 
   EXPECT_CALL(*manager(), state())
       .WillOnce(Return(DataTypeManager::CONFIGURING));
   EXPECT_CALL(*manager(), Configure(_, _)).Times(0);
   migrator()->MigrateTypes(to_migrate);
   EXPECT_EQ(BackendMigrator::WAITING_TO_START, migrator()->state());
 
   Mock::VerifyAndClearExpectations(manager());
   EXPECT_CALL(*manager(), state())
       .WillOnce(Return(DataTypeManager::CONFIGURED));
-  EXPECT_CALL(*manager(), Configure(_, syncer::CONFIGURE_REASON_MIGRATION));
+  EXPECT_CALL(*manager(),
+              PurgeForMigration(_, syncer::CONFIGURE_REASON_MIGRATION));
   SetUnsyncedTypes(syncer::ModelTypeSet());
   SendConfigureDone(DataTypeManager::OK, syncer::ModelTypeSet());
 
   EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state());
 }
 
 // Test that the migrator can cope with a migration request while a migration
 // is in progress.
 TEST_F(SyncBackendMigratorTest, RestartMigration) {
   syncer::ModelTypeSet to_migrate1, to_migrate2, to_migrate_union, bookmarks;
   to_migrate1.Put(syncer::PREFERENCES);
   to_migrate2.Put(syncer::AUTOFILL);
   to_migrate_union.Put(syncer::PREFERENCES);
   to_migrate_union.Put(syncer::AUTOFILL);
   bookmarks.Put(syncer::BOOKMARKS);
 
   EXPECT_CALL(*manager(), state())
       .WillOnce(Return(DataTypeManager::CONFIGURED));
-  EXPECT_CALL(*manager(), Configure(_, syncer::CONFIGURE_REASON_MIGRATION))
-              .Times(2);
+  EXPECT_CALL(
+      *manager(),
+      PurgeForMigration(_, syncer::CONFIGURE_REASON_MIGRATION)).Times(2);
   migrator()->MigrateTypes(to_migrate1);
 
   EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state());
   migrator()->MigrateTypes(to_migrate2);
 
   const syncer::ModelTypeSet difference1 =
       Difference(preferred_types(), to_migrate1);
 
   Mock::VerifyAndClearExpectations(manager());
+  EXPECT_CALL(
+      *manager(),
+      PurgeForMigration(_, syncer::CONFIGURE_REASON_MIGRATION)).Times(1);
   EXPECT_CALL(*manager(), Configure(_, syncer::CONFIGURE_REASON_MIGRATION))
-      .Times(2);
+      .Times(1);
   SetUnsyncedTypes(to_migrate1);
   SendConfigureDone(DataTypeManager::OK, difference1);
   EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state());
 
   SetUnsyncedTypes(to_migrate_union);
   SendConfigureDone(DataTypeManager::OK, bookmarks);
   EXPECT_EQ(BackendMigrator::REENABLING_TYPES, migrator()->state());
 }
 
 // Test that an external invocation of Configure(...) during a migration results
 // in a migration reattempt.
 TEST_F(SyncBackendMigratorTest, InterruptedWhileDisablingTypes) {
   syncer::ModelTypeSet to_migrate;
   syncer::ModelTypeSet difference;
   to_migrate.Put(syncer::PREFERENCES);
   difference.Put(syncer::AUTOFILL);
   difference.Put(syncer::BOOKMARKS);
 
   EXPECT_CALL(*manager(), state())
       .WillOnce(Return(DataTypeManager::CONFIGURED));
-  EXPECT_CALL(*manager(), Configure(HasModelTypes(difference),
+  EXPECT_CALL(*manager(), PurgeForMigration(HasModelTypes(to_migrate),
       syncer::CONFIGURE_REASON_MIGRATION));
   migrator()->MigrateTypes(to_migrate);
   EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state());
 
   Mock::VerifyAndClearExpectations(manager());
-  EXPECT_CALL(*manager(), Configure(HasModelTypes(difference),
+  EXPECT_CALL(*manager(), PurgeForMigration(HasModelTypes(to_migrate),
       syncer::CONFIGURE_REASON_MIGRATION));
   SetUnsyncedTypes(syncer::ModelTypeSet());
   SendConfigureDone(DataTypeManager::OK, preferred_types());
 
   EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state());
 }
 
 // Test that spurious OnConfigureDone events don't confuse the
 // migrator while it's waiting for disabled types to have been purged
 // from the sync db.
 TEST_F(SyncBackendMigratorTest, WaitingForPurge) {
   syncer::ModelTypeSet to_migrate, difference;
   to_migrate.Put(syncer::PREFERENCES);
   to_migrate.Put(syncer::AUTOFILL);
   difference.Put(syncer::BOOKMARKS);
 
   EXPECT_CALL(*manager(), state())
       .WillOnce(Return(DataTypeManager::CONFIGURED));
-  EXPECT_CALL(*manager(), Configure(_, syncer::CONFIGURE_REASON_MIGRATION))
-      .Times(2);
+  EXPECT_CALL(
+      *manager(),
+      PurgeForMigration(_, syncer::CONFIGURE_REASON_MIGRATION)).Times(1);
+  EXPECT_CALL(
+      *manager(),
+      Configure(_, syncer::CONFIGURE_REASON_MIGRATION)).Times(1);
 
   migrator()->MigrateTypes(to_migrate);
   EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state());
 
   SendConfigureDone(DataTypeManager::OK, difference);
   EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state());
 
   syncer::ModelTypeSet prefs;
   prefs.Put(syncer::PREFERENCES);
   SetUnsyncedTypes(prefs);
   SendConfigureDone(DataTypeManager::OK, difference);
   EXPECT_EQ(BackendMigrator::DISABLING_TYPES, migrator()->state());
 
   SetUnsyncedTypes(to_migrate);
   SendConfigureDone(DataTypeManager::OK, difference);
   EXPECT_EQ(BackendMigrator::REENABLING_TYPES, migrator()->state());
 }
 
 TEST_F(SyncBackendMigratorTest, MigratedTypeDisabledByUserDuringMigration) {
   syncer::ModelTypeSet to_migrate;
   to_migrate.Put(syncer::PREFERENCES);
 
   EXPECT_CALL(*manager(), state())
       .WillOnce(Return(DataTypeManager::CONFIGURED));
-  EXPECT_CALL(*manager(), Configure(_, syncer::CONFIGURE_REASON_MIGRATION))
-      .Times(2);
+  EXPECT_CALL(
+      *manager(),
+      PurgeForMigration(_, syncer::CONFIGURE_REASON_MIGRATION)).Times(1);
+  EXPECT_CALL(
+      *manager(),
+      Configure(_, syncer::CONFIGURE_REASON_MIGRATION)).Times(1);
   migrator()->MigrateTypes(to_migrate);
 
   RemovePreferredType(syncer::PREFERENCES);
   SetUnsyncedTypes(to_migrate);
   SendConfigureDone(DataTypeManager::OK, preferred_types());
   EXPECT_EQ(BackendMigrator::REENABLING_TYPES, migrator()->state());
   SetUnsyncedTypes(syncer::ModelTypeSet());
   SendConfigureDone(DataTypeManager::OK, preferred_types());
   EXPECT_EQ(BackendMigrator::IDLE, migrator()->state());
 }
 
 TEST_F(SyncBackendMigratorTest, ConfigureFailure) {
   syncer::ModelTypeSet to_migrate;
   to_migrate.Put(syncer::PREFERENCES);
 
   EXPECT_CALL(*manager(), state())
       .WillOnce(Return(DataTypeManager::CONFIGURED));
-  EXPECT_CALL(*manager(), Configure(_, syncer::CONFIGURE_REASON_MIGRATION))
-              .Times(1);
+  EXPECT_CALL(
+      *manager(),
+      PurgeForMigration(_, syncer::CONFIGURE_REASON_MIGRATION)).Times(1);
   migrator()->MigrateTypes(to_migrate);
   SetUnsyncedTypes(syncer::ModelTypeSet());
   SendConfigureDone(DataTypeManager::ABORTED, syncer::ModelTypeSet());
   EXPECT_EQ(BackendMigrator::IDLE, migrator()->state());
 }
 
 };  // namespace browser_sync