[Sync] Ensure that CONFIGURE_CLEAN types get unapplied before configuration

components/sync/driver/glue/sync_backend_host_impl_unittest.cc

 // Copyright 2013 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 "components/sync/driver/glue/sync_backend_host_impl.h"
 
 #include <cstddef>
 #include <utility>
 
 #include "base/files/file_util.h"
@@ skipping 223 matching lines @@
     base::RunLoop run_loop;
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, run_loop.QuitClosure(), TestTimeouts::action_timeout());
     run_loop.Run();
     // |fake_manager_factory_|'s fake_manager() is set on the sync
     // thread, but we can rely on the message loop barriers to
     // guarantee that we see the updated value.
     DCHECK(fake_manager_);
   }
 
-  // Synchronously configures the backend's datatypes.
-  ModelTypeSet ConfigureDataTypes(ModelTypeSet types_to_add,
-                                  ModelTypeSet types_to_remove,
-                                  ModelTypeSet types_to_unapply) {
+  // Returns DataTypeConfigStateMap with all |enabled_types_| in
+  // CONFIGURE_ACTIVE state and all remaining types DISABLED.
+  ModelTypeConfigurer::DataTypeConfigStateMap ConfigStateMapForEnabledTypes() {
     ModelTypeConfigurer::DataTypeConfigStateMap config_state_map;
     ModelTypeConfigurer::SetDataTypesState(
-        ModelTypeConfigurer::CONFIGURE_ACTIVE, types_to_add, &config_state_map);
-    ModelTypeConfigurer::SetDataTypesState(ModelTypeConfigurer::DISABLED,
-                                           types_to_remove, &config_state_map);
-    ModelTypeConfigurer::SetDataTypesState(ModelTypeConfigurer::UNREADY,
-                                           types_to_unapply, &config_state_map);
+        ModelTypeConfigurer::CONFIGURE_ACTIVE, enabled_types_,
+        &config_state_map);
+    ModelTypeConfigurer::SetDataTypesState(
+        ModelTypeConfigurer::DISABLED,
+        Difference(ModelTypeSet::All(), enabled_types_), &config_state_map);
+    return config_state_map;
+  }
 
-    types_to_add.PutAll(ControlTypes());
+  // Synchronously configures the backend's datatypes.
+  ModelTypeSet ConfigureDataTypes(
+      const ModelTypeConfigurer::DataTypeConfigStateMap& config_state_map) {
     ModelTypeSet ready_types = backend_->ConfigureDataTypes(
         CONFIGURE_REASON_RECONFIGURATION, config_state_map,
         base::Bind(&SyncEngineTest::DownloadReady, base::Unretained(this)),
         base::Bind(&SyncEngineTest::OnDownloadRetry, base::Unretained(this)));
     base::RunLoop run_loop;
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, run_loop.QuitClosure(), TestTimeouts::action_timeout());
     run_loop.Run();
     return ready_types;
   }
@@ skipping 36 matching lines @@
 // Test first time sync scenario. All types should be properly configured.
 
 TEST_F(SyncEngineTest, FirstTimeSync) {
   InitializeBackend(true);
   EXPECT_EQ(ControlTypes(), fake_manager_->GetAndResetDownloadedTypes());
   EXPECT_EQ(ControlTypes(), fake_manager_->InitialSyncEndedTypes());
   EXPECT_TRUE(
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(ControlTypes())
           .Empty());
 
-  ModelTypeSet ready_types = ConfigureDataTypes(
-      enabled_types_, Difference(ModelTypeSet::All(), enabled_types_),
-      ModelTypeSet());
+  ModelTypeSet ready_types =
+      ConfigureDataTypes(ConfigStateMapForEnabledTypes());
   // Nigori is always downloaded so won't be ready.
   EXPECT_EQ(Difference(ControlTypes(), ModelTypeSet(NIGORI)), ready_types);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().HasAll(
       Difference(enabled_types_, ControlTypes())));
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetEnabledTypes());
   EXPECT_TRUE(
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
           .Empty());
 }
 
 // Test the restart after setting up sync scenario. No enabled types should be
 // downloaded or cleaned.
 TEST_F(SyncEngineTest, Restart) {
   sync_prefs_->SetFirstSetupComplete();
   ModelTypeSet all_but_nigori = enabled_types_;
   fake_manager_factory_->set_progress_marker_types(enabled_types_);
   fake_manager_factory_->set_initial_sync_ended_types(enabled_types_);
   InitializeBackend(true);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty());
   EXPECT_TRUE(
-      Intersection(fake_manager_->GetAndResetCleanedTypes(), enabled_types_)
+      Intersection(fake_manager_->GetAndResetPurgedTypes(), enabled_types_)
           .Empty());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_TRUE(
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
           .Empty());
 
-  ModelTypeSet ready_types = ConfigureDataTypes(
-      enabled_types_, Difference(ModelTypeSet::All(), enabled_types_),
-      ModelTypeSet());
+  ModelTypeSet ready_types =
+      ConfigureDataTypes(ConfigStateMapForEnabledTypes());
   EXPECT_EQ(enabled_types_, ready_types);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty());
   EXPECT_TRUE(
-      Intersection(fake_manager_->GetAndResetCleanedTypes(), enabled_types_)
+      Intersection(fake_manager_->GetAndResetPurgedTypes(), enabled_types_)
           .Empty());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetEnabledTypes());
   EXPECT_TRUE(
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
           .Empty());
 }
 
 // Test a sync restart scenario where some types had never finished configuring.
 // The partial types should be purged, then reconfigured properly.
 TEST_F(SyncEngineTest, PartialTypes) {
   sync_prefs_->SetFirstSetupComplete();
   // Set sync manager behavior before passing it down. All types have progress
   // markers, but nigori and bookmarks are missing initial sync ended.
   ModelTypeSet partial_types(NIGORI, BOOKMARKS);
   ModelTypeSet full_types = Difference(enabled_types_, partial_types);
   fake_manager_factory_->set_progress_marker_types(enabled_types_);
   fake_manager_factory_->set_initial_sync_ended_types(full_types);
 
   // Bringing up the backend should purge all partial types, then proceed to
   // download the Nigori.
   InitializeBackend(true);
   EXPECT_EQ(ModelTypeSet(NIGORI), fake_manager_->GetAndResetDownloadedTypes());
-  EXPECT_TRUE(fake_manager_->GetAndResetCleanedTypes().HasAll(partial_types));
+  EXPECT_TRUE(fake_manager_->GetAndResetPurgedTypes().HasAll(partial_types));
   EXPECT_EQ(Union(full_types, ModelTypeSet(NIGORI)),
             fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(
       Difference(partial_types, ModelTypeSet(NIGORI)),
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_));
 
   // Now do the actual configuration, which should download and apply bookmarks.
-  ModelTypeSet ready_types = ConfigureDataTypes(
-      enabled_types_, Difference(ModelTypeSet::All(), enabled_types_),
-      ModelTypeSet());
+  ModelTypeSet ready_types =
+      ConfigureDataTypes(ConfigStateMapForEnabledTypes());
   EXPECT_EQ(full_types, ready_types);
   EXPECT_TRUE(
-      Intersection(fake_manager_->GetAndResetCleanedTypes(), enabled_types_)
+      Intersection(fake_manager_->GetAndResetPurgedTypes(), enabled_types_)
           .Empty());
   EXPECT_EQ(partial_types, fake_manager_->GetAndResetDownloadedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetEnabledTypes());
   EXPECT_TRUE(
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
           .Empty());
 }
 
 // Test the behavior when we lose the sync db. Although we already have types
 // enabled, we should re-download all of them because we lost their data.
 TEST_F(SyncEngineTest, LostDB) {
   sync_prefs_->SetFirstSetupComplete();
   // Initialization should fetch the Nigori node.  Everything else should be
   // left untouched.
   InitializeBackend(true);
   EXPECT_EQ(ModelTypeSet(ControlTypes()),
             fake_manager_->GetAndResetDownloadedTypes());
   EXPECT_EQ(ModelTypeSet(ControlTypes()),
             fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(
       Difference(enabled_types_, ControlTypes()),
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_));
 
   // The database was empty, so any cleaning is entirely optional.  We want to
   // reset this value before running the next part of the test, though.
-  fake_manager_->GetAndResetCleanedTypes();
+  fake_manager_->GetAndResetPurgedTypes();
 
   // The actual configuration should redownload and apply all the enabled types.
-  ModelTypeSet ready_types = ConfigureDataTypes(
-      enabled_types_, Difference(ModelTypeSet::All(), enabled_types_),
-      ModelTypeSet());
+  ModelTypeSet ready_types =
+      ConfigureDataTypes(ConfigStateMapForEnabledTypes());
   // Nigori is always downloaded so won't be ready.
   EXPECT_EQ(Difference(ControlTypes(), ModelTypeSet(NIGORI)), ready_types);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().HasAll(
       Difference(enabled_types_, ControlTypes())));
   EXPECT_TRUE(
-      Intersection(fake_manager_->GetAndResetCleanedTypes(), enabled_types_)
+      Intersection(fake_manager_->GetAndResetPurgedTypes(), enabled_types_)
           .Empty());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetEnabledTypes());
   EXPECT_TRUE(
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
           .Empty());
 }
 
 TEST_F(SyncEngineTest, DisableTypes) {
   // Simulate first time sync.
   InitializeBackend(true);
-  fake_manager_->GetAndResetCleanedTypes();
-  ModelTypeSet ready_types = ConfigureDataTypes(
-      enabled_types_, Difference(ModelTypeSet::All(), enabled_types_),
-      ModelTypeSet());
+  fake_manager_->GetAndResetPurgedTypes();
+  ModelTypeSet ready_types =
+      ConfigureDataTypes(ConfigStateMapForEnabledTypes());
   // Nigori is always downloaded so won't be ready.
   EXPECT_EQ(Difference(ControlTypes(), ModelTypeSet(NIGORI)), ready_types);
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetDownloadedTypes());
   EXPECT_TRUE(
-      Intersection(fake_manager_->GetAndResetCleanedTypes(), enabled_types_)
+      Intersection(fake_manager_->GetAndResetPurgedTypes(), enabled_types_)
           .Empty());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_TRUE(
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
           .Empty());
 
   // Then disable two datatypes.
   ModelTypeSet disabled_types(BOOKMARKS, SEARCH_ENGINES);
   ModelTypeSet old_types = enabled_types_;
   enabled_types_.RemoveAll(disabled_types);
-  ready_types = ConfigureDataTypes(
-      enabled_types_, Difference(ModelTypeSet::All(), enabled_types_),
-      ModelTypeSet());
+  ready_types = ConfigureDataTypes(ConfigStateMapForEnabledTypes());
 
   // Only those datatypes disabled should be cleaned. Nothing should be
   // downloaded.
   EXPECT_EQ(enabled_types_, ready_types);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty());
   EXPECT_EQ(disabled_types,
-            Intersection(fake_manager_->GetAndResetCleanedTypes(), old_types));
+            Intersection(fake_manager_->GetAndResetPurgedTypes(), old_types));
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetEnabledTypes());
   EXPECT_TRUE(
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
           .Empty());
 }
 
 TEST_F(SyncEngineTest, AddTypes) {
   // Simulate first time sync.
   InitializeBackend(true);
-  fake_manager_->GetAndResetCleanedTypes();
-  ModelTypeSet ready_types = ConfigureDataTypes(
-      enabled_types_, Difference(ModelTypeSet::All(), enabled_types_),
-      ModelTypeSet());
+  fake_manager_->GetAndResetPurgedTypes();
+  ModelTypeSet ready_types =
+      ConfigureDataTypes(ConfigStateMapForEnabledTypes());
   // Nigori is always downloaded so won't be ready.
   EXPECT_EQ(Difference(ControlTypes(), ModelTypeSet(NIGORI)), ready_types);
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetDownloadedTypes());
   EXPECT_TRUE(
-      Intersection(fake_manager_->GetAndResetCleanedTypes(), enabled_types_)
+      Intersection(fake_manager_->GetAndResetPurgedTypes(), enabled_types_)
           .Empty());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_TRUE(
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
           .Empty());
 
   // Then add two datatypes.
   ModelTypeSet new_types(EXTENSIONS, APPS);
   enabled_types_.PutAll(new_types);
-  ready_types = ConfigureDataTypes(
-      enabled_types_, Difference(ModelTypeSet::All(), enabled_types_),
-      ModelTypeSet());
+  ready_types = ConfigureDataTypes(ConfigStateMapForEnabledTypes());
 
   // Only those datatypes added should be downloaded (plus nigori). Nothing
   // should be cleaned aside from the disabled types.
   new_types.Put(NIGORI);
   EXPECT_EQ(Difference(enabled_types_, new_types), ready_types);
   EXPECT_EQ(new_types, fake_manager_->GetAndResetDownloadedTypes());
   EXPECT_TRUE(
-      Intersection(fake_manager_->GetAndResetCleanedTypes(), enabled_types_)
+      Intersection(fake_manager_->GetAndResetPurgedTypes(), enabled_types_)
           .Empty());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetEnabledTypes());
   EXPECT_TRUE(
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
           .Empty());
 }
 
 // And and disable in the same configuration.
 TEST_F(SyncEngineTest, AddDisableTypes) {
   // Simulate first time sync.
   InitializeBackend(true);
-  fake_manager_->GetAndResetCleanedTypes();
-  ModelTypeSet ready_types = ConfigureDataTypes(
-      enabled_types_, Difference(ModelTypeSet::All(), enabled_types_),
-      ModelTypeSet());
+  fake_manager_->GetAndResetPurgedTypes();
+  ModelTypeSet ready_types =
+      ConfigureDataTypes(ConfigStateMapForEnabledTypes());
   // Nigori is always downloaded so won't be ready.
   EXPECT_EQ(Difference(ControlTypes(), ModelTypeSet(NIGORI)), ready_types);
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetDownloadedTypes());
   EXPECT_TRUE(
-      Intersection(fake_manager_->GetAndResetCleanedTypes(), enabled_types_)
+      Intersection(fake_manager_->GetAndResetPurgedTypes(), enabled_types_)
           .Empty());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_TRUE(
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
           .Empty());
 
   // Then add two datatypes.
   ModelTypeSet old_types = enabled_types_;
   ModelTypeSet disabled_types(BOOKMARKS, SEARCH_ENGINES);
   ModelTypeSet new_types(EXTENSIONS, APPS);
   enabled_types_.PutAll(new_types);
   enabled_types_.RemoveAll(disabled_types);
-  ready_types = ConfigureDataTypes(
-      enabled_types_, Difference(ModelTypeSet::All(), enabled_types_),
-      ModelTypeSet());
+  ready_types = ConfigureDataTypes(ConfigStateMapForEnabledTypes());
 
   // Only those datatypes added should be downloaded (plus nigori). Nothing
   // should be cleaned aside from the disabled types.
   new_types.Put(NIGORI);
   EXPECT_EQ(Difference(enabled_types_, new_types), ready_types);
   EXPECT_EQ(new_types, fake_manager_->GetAndResetDownloadedTypes());
   EXPECT_EQ(disabled_types,
-            Intersection(fake_manager_->GetAndResetCleanedTypes(), old_types));
+            Intersection(fake_manager_->GetAndResetPurgedTypes(), old_types));
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetEnabledTypes());
   EXPECT_EQ(disabled_types,
             fake_manager_->GetTypesWithEmptyProgressMarkerToken(old_types));
 }
 
 // Test restarting the browser to newly supported datatypes. The new datatypes
 // should be downloaded on the configuration after backend initialization.
 TEST_F(SyncEngineTest, NewlySupportedTypes) {
   sync_prefs_->SetFirstSetupComplete();
   // Set sync manager behavior before passing it down. All types have progress
   // markers and initial sync ended except the new types.
   ModelTypeSet old_types = enabled_types_;
   fake_manager_factory_->set_progress_marker_types(old_types);
   fake_manager_factory_->set_initial_sync_ended_types(old_types);
   ModelTypeSet new_types(APP_SETTINGS, EXTENSION_SETTINGS);
   enabled_types_.PutAll(new_types);
 
   // Does nothing.
   InitializeBackend(true);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty());
-  EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(), old_types)
-                  .Empty());
+  EXPECT_TRUE(
+      Intersection(fake_manager_->GetAndResetPurgedTypes(), old_types).Empty());
   EXPECT_EQ(old_types, fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(new_types, fake_manager_->GetTypesWithEmptyProgressMarkerToken(
                            enabled_types_));
 
   // Downloads and applies the new types (plus nigori).
-  ModelTypeSet ready_types = ConfigureDataTypes(
-      enabled_types_, Difference(ModelTypeSet::All(), enabled_types_),
-      ModelTypeSet());
+  ModelTypeSet ready_types =
+      ConfigureDataTypes(ConfigStateMapForEnabledTypes());
 
   new_types.Put(NIGORI);
   EXPECT_EQ(Difference(old_types, ModelTypeSet(NIGORI)), ready_types);
   EXPECT_EQ(new_types, fake_manager_->GetAndResetDownloadedTypes());
   EXPECT_TRUE(
-      Intersection(fake_manager_->GetAndResetCleanedTypes(), enabled_types_)
+      Intersection(fake_manager_->GetAndResetPurgedTypes(), enabled_types_)
           .Empty());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetEnabledTypes());
   EXPECT_TRUE(
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
           .Empty());
 }
 
 // Test the newly supported types scenario, but with the presence of partial
 // types as well. Both partial and newly supported types should be downloaded
 // the configuration.
 TEST_F(SyncEngineTest, NewlySupportedTypesWithPartialTypes) {
   sync_prefs_->SetFirstSetupComplete();
   // Set sync manager behavior before passing it down. All types have progress
   // markers and initial sync ended except the new types.
   ModelTypeSet old_types = enabled_types_;
   ModelTypeSet partial_types(NIGORI, BOOKMARKS);
   ModelTypeSet full_types = Difference(enabled_types_, partial_types);
   fake_manager_factory_->set_progress_marker_types(old_types);
   fake_manager_factory_->set_initial_sync_ended_types(full_types);
   ModelTypeSet new_types(APP_SETTINGS, EXTENSION_SETTINGS);
   enabled_types_.PutAll(new_types);
 
   // Purge the partial types.  The nigori will be among the purged types, but
   // the syncer will re-download it by the time the initialization is complete.
   InitializeBackend(true);
   EXPECT_EQ(ModelTypeSet(NIGORI), fake_manager_->GetAndResetDownloadedTypes());
-  EXPECT_TRUE(fake_manager_->GetAndResetCleanedTypes().HasAll(partial_types));
+  EXPECT_TRUE(fake_manager_->GetAndResetPurgedTypes().HasAll(partial_types));
   EXPECT_EQ(Union(full_types, ModelTypeSet(NIGORI)),
             fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(
       Union(new_types, Difference(partial_types, ModelTypeSet(NIGORI))),
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_));
 
   // Downloads and applies the new types and partial types (which includes
   // nigori anyways).
-  ModelTypeSet ready_types = ConfigureDataTypes(
-      enabled_types_, Difference(ModelTypeSet::All(), enabled_types_),
-      ModelTypeSet());
+  ModelTypeSet ready_types =
+      ConfigureDataTypes(ConfigStateMapForEnabledTypes());
   EXPECT_EQ(full_types, ready_types);
   EXPECT_EQ(Union(new_types, partial_types),
             fake_manager_->GetAndResetDownloadedTypes());
   EXPECT_TRUE(
-      Intersection(fake_manager_->GetAndResetCleanedTypes(), enabled_types_)
+      Intersection(fake_manager_->GetAndResetPurgedTypes(), enabled_types_)
           .Empty());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetEnabledTypes());
   EXPECT_TRUE(
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
           .Empty());
 }
 
 // Verify that downloading control types only downloads those types that do
 // not have initial sync ended set.
 TEST_F(SyncEngineTest, DownloadControlTypes) {
   sync_prefs_->SetFirstSetupComplete();
   // Set sync manager behavior before passing it down. Experiments and device
   // info are new types without progress markers or initial sync ended, while
   // all other types have been fully downloaded and applied.
   ModelTypeSet new_types(EXPERIMENTS, NIGORI);
   ModelTypeSet old_types = Difference(enabled_types_, new_types);
   fake_manager_factory_->set_progress_marker_types(old_types);
   fake_manager_factory_->set_initial_sync_ended_types(old_types);
 
   // Bringing up the backend should download the new types without downloading
   // any old types.
   InitializeBackend(true);
   EXPECT_EQ(new_types, fake_manager_->GetAndResetDownloadedTypes());
   EXPECT_EQ(Difference(ModelTypeSet::All(), enabled_types_),
-            fake_manager_->GetAndResetCleanedTypes());
+            fake_manager_->GetAndResetPurgedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_TRUE(
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
           .Empty());
 }
 
 // Fail to download control types.  It's believed that there is a server bug
 // which can allow this to happen (crbug.com/164288).  The sync backend host
 // should detect this condition and fail to initialize the backend.
 //
@@ skipping 55 matching lines @@
 // If bookmarks encounter an error that results in disabling without purging
 // (such as when the type is unready), and then is explicitly disabled, the
 // SyncEngine needs to tell the manager to purge the type, even though
 // it's already disabled (crbug.com/386778).
 TEST_F(SyncEngineTest, DisableThenPurgeType) {
   ModelTypeSet error_types(BOOKMARKS);
 
   InitializeBackend(true);
 
   // First enable the types.
-  ModelTypeSet ready_types = ConfigureDataTypes(
-      enabled_types_, Difference(ModelTypeSet::All(), enabled_types_),
-      ModelTypeSet());
+  ModelTypeSet ready_types =
+      ConfigureDataTypes(ConfigStateMapForEnabledTypes());
 
   // Nigori is always downloaded so won't be ready.
   EXPECT_EQ(Difference(ControlTypes(), ModelTypeSet(NIGORI)), ready_types);
 
   // Then mark the error types as unready (disables without purging).
-  ready_types = ConfigureDataTypes(
-      enabled_types_, Difference(ModelTypeSet::All(), enabled_types_),
-      error_types);
+  ModelTypeConfigurer::DataTypeConfigStateMap config_state_map =
+      ConfigStateMapForEnabledTypes();
+  ModelTypeConfigurer::SetDataTypesState(ModelTypeConfigurer::UNREADY,
+                                         error_types, &config_state_map);
+  ready_types = ConfigureDataTypes(config_state_map);
   EXPECT_EQ(Difference(enabled_types_, error_types), ready_types);
   EXPECT_TRUE(
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(error_types).Empty());
 
   // Lastly explicitly disable the error types, which should result in a purge.
   enabled_types_.RemoveAll(error_types);
-  ready_types = ConfigureDataTypes(
-      enabled_types_, Difference(ModelTypeSet::All(), enabled_types_),
-      ModelTypeSet());
+  ready_types = ConfigureDataTypes(ConfigStateMapForEnabledTypes());
   EXPECT_EQ(Difference(enabled_types_, error_types), ready_types);
   EXPECT_FALSE(
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(error_types).Empty());
 }
 
 // Test that a call to ClearServerData is forwarded to the underlying
 // SyncManager.
 TEST_F(SyncEngineTest, ClearServerDataCallsAreForwarded) {
   InitializeBackend(true);
   CallbackCounter callback_counter;
@@ skipping 68 matching lines @@
 // DataTypeManager shutdown.
 TEST_F(SyncEngineTest, ModelTypeConnectorValidDuringShutdown) {
   InitializeBackend(true);
   backend_->StopSyncingForShutdown();
   // Verify that call to DeactivateNonBlockingDataType doesn't assert.
   backend_->DeactivateNonBlockingDataType(AUTOFILL);
   backend_->Shutdown(STOP_SYNC);
   backend_.reset();
 }
 
+// Ensure that types in CONFIGURE_CLEAN state are unapplied.
+TEST_F(SyncEngineTest, ConfigureCelanTypesAreUnapplied) {
+  ModelTypeSet clean_types(AUTOFILL);
+
+  InitializeBackend(true);
+
+  // First enable the types.
+  ModelTypeSet ready_types =
+      ConfigureDataTypes(ConfigStateMapForEnabledTypes());
+  EXPECT_TRUE(
+      fake_manager_->GetTypesWithEmptyProgressMarkerToken(clean_types).Empty());
+
+  // Then unapply AUTOFILL.
+  ModelTypeConfigurer::DataTypeConfigStateMap config_state_map =
+      ConfigStateMapForEnabledTypes();
+  ModelTypeConfigurer::SetDataTypesState(ModelTypeConfigurer::CONFIGURE_CLEAN,
+                                         clean_types, &config_state_map);
+
+  ready_types = ConfigureDataTypes(config_state_map);
+
+  // Autofill should be unapplied as part of PurgeDisabledTypes, but should
+  // retain progress markers.
+  ModelTypeSet purged_types = fake_manager_->GetAndResetPurgedTypes();
+  ModelTypeSet unapplied_types = fake_manager_->GetAndResetUnappliedTypes();
+  EXPECT_EQ(unapplied_types, clean_types);
+  EXPECT_TRUE(purged_types.HasAll(clean_types));
+  EXPECT_TRUE(
+      fake_manager_->GetTypesWithEmptyProgressMarkerToken(clean_types).Empty());
+}
+
 }  // namespace
 
 }  // namespace syncer