[Sync] Have configuration specify which datatypes are ready to sync

chrome/browser/sync/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 "chrome/browser/sync/glue/sync_backend_host_impl.h"
 
 #include <cstddef>
 
 #include "base/files/file_util.h"
 #include "base/location.h"
@@ skipping 158 matching lines @@
     credentials_.scope_set.insert(GaiaConstants::kChromeSyncOAuth2Scope);
 
     fake_manager_factory_.reset(new FakeSyncManagerFactory(&fake_manager_));
 
     // These types are always implicitly enabled.
     enabled_types_.PutAll(syncer::ControlTypes());
 
     // NOTE: We can't include Passwords or Typed URLs due to the Sync Backend
     // Registrar removing them if it can't find their model workers.
     enabled_types_.Put(syncer::BOOKMARKS);
-    enabled_types_.Put(syncer::NIGORI);
-    enabled_types_.Put(syncer::DEVICE_INFO);
     enabled_types_.Put(syncer::PREFERENCES);
     enabled_types_.Put(syncer::SESSIONS);
     enabled_types_.Put(syncer::SEARCH_ENGINES);
     enabled_types_.Put(syncer::AUTOFILL);
-    enabled_types_.Put(syncer::EXPERIMENTS);
 
     network_resources_.reset(new syncer::HttpBridgeNetworkResources());
   }
 
   virtual void TearDown() override {
     if (backend_) {
       backend_->StopSyncingForShutdown();
       backend_->Shutdown(syncer::STOP_SYNC);
     }
     backend_.reset();
@@ skipping 28 matching lines @@
                                    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.
-  void ConfigureDataTypes(syncer::ModelTypeSet types_to_add,
-                          syncer::ModelTypeSet types_to_remove,
-                          syncer::ModelTypeSet types_to_unapply) {
+  syncer::ModelTypeSet ConfigureDataTypes(
+      syncer::ModelTypeSet types_to_add,
+      syncer::ModelTypeSet types_to_remove,
+      syncer::ModelTypeSet types_to_unapply) {
     sync_driver::BackendDataTypeConfigurer::DataTypeConfigStateMap
         config_state_map;
     sync_driver::BackendDataTypeConfigurer::SetDataTypesState(
         sync_driver::BackendDataTypeConfigurer::CONFIGURE_ACTIVE,
         types_to_add,
         &config_state_map);
     sync_driver::BackendDataTypeConfigurer::SetDataTypesState(
         sync_driver::BackendDataTypeConfigurer::DISABLED,
         types_to_remove, &config_state_map);
     sync_driver::BackendDataTypeConfigurer::SetDataTypesState(
         sync_driver::BackendDataTypeConfigurer::UNREADY,
         types_to_unapply, &config_state_map);
 
     types_to_add.PutAll(syncer::ControlTypes());
-    backend_->ConfigureDataTypes(
-        syncer::CONFIGURE_REASON_RECONFIGURATION,
-        config_state_map,
-        base::Bind(&SyncBackendHostTest::DownloadReady,
-                   base::Unretained(this)),
+    syncer::ModelTypeSet ready_types = backend_->ConfigureDataTypes(
+        syncer::CONFIGURE_REASON_RECONFIGURATION, config_state_map,
+        base::Bind(&SyncBackendHostTest::DownloadReady, base::Unretained(this)),
         base::Bind(&SyncBackendHostTest::OnDownloadRetry,
                    base::Unretained(this)));
     base::RunLoop run_loop;
     BrowserThread::PostDelayedTask(BrowserThread::UI, FROM_HERE,
                                    run_loop.QuitClosure(),
                                    TestTimeouts::action_timeout());
     run_loop.Run();
+    return ready_types;
   }
 
   void IssueRefreshRequest(syncer::ModelTypeSet types) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_SYNC_REFRESH_LOCAL,
         content::Source<Profile>(profile_),
         content::Details<syncer::ModelTypeSet>(&types));
   }
@@ skipping 36 matching lines @@
 // Test first time sync scenario. All types should be properly configured.
 TEST_F(SyncBackendHostTest, FirstTimeSync) {
   InitializeBackend(true);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
       syncer::ControlTypes()));
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(
       syncer::ControlTypes()));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       syncer::ControlTypes()).Empty());
 
-  ConfigureDataTypes(enabled_types_,
-                     Difference(syncer::ModelTypeSet::All(),
-                                enabled_types_),
-                     syncer::ModelTypeSet());
+  syncer::ModelTypeSet ready_types = ConfigureDataTypes(
+      enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
+      syncer::ModelTypeSet());
+  // Nigori is always downloaded so won't be ready.
+  EXPECT_TRUE(ready_types.Equals(syncer::Difference(
+      syncer::ControlTypes(),
+      syncer::ModelTypeSet(syncer::NIGORI))));
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().HasAll(
       Difference(enabled_types_, syncer::ControlTypes())));
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
   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(SyncBackendHostTest, Restart) {
   sync_prefs_->SetSyncSetupCompleted();
   syncer::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_).Empty());
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Empty());
 
-  ConfigureDataTypes(enabled_types_,
-                     Difference(syncer::ModelTypeSet::All(),
-                                enabled_types_),
-                     syncer::ModelTypeSet());
+  syncer::ModelTypeSet ready_types = ConfigureDataTypes(
+      enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
+      syncer::ModelTypeSet());
+  EXPECT_TRUE(ready_types.Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty());
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            enabled_types_).Empty());
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Empty());
 }
 
 // Test a sync restart scenario where some types had never finished configuring.
@@ skipping 14 matching lines @@
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
       syncer::ModelTypeSet(syncer::NIGORI)));
   EXPECT_TRUE(fake_manager_->GetAndResetCleanedTypes().HasAll(partial_types));
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(
       Union(full_types, syncer::ModelTypeSet(syncer::NIGORI))));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Equals(
           Difference(partial_types, syncer::ModelTypeSet(syncer::NIGORI))));
 
   // Now do the actual configuration, which should download and apply bookmarks.
-  ConfigureDataTypes(enabled_types_,
-                     Difference(syncer::ModelTypeSet::All(),
-                                enabled_types_),
-                     syncer::ModelTypeSet());
+  syncer::ModelTypeSet ready_types = ConfigureDataTypes(
+      enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
+      syncer::ModelTypeSet());
+  EXPECT_TRUE(ready_types.Equals(full_types));
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            enabled_types_).Empty());
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
       partial_types));
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Empty());
 }
 
@@ skipping 10 matching lines @@
       syncer::ModelTypeSet(syncer::ControlTypes())));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Equals(
           Difference(enabled_types_, syncer::ControlTypes())));
 
   // 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();
 
   // The actual configuration should redownload and apply all the enabled types.
-  ConfigureDataTypes(enabled_types_,
-                     Difference(syncer::ModelTypeSet::All(),
-                                enabled_types_),
-                     syncer::ModelTypeSet());
+  syncer::ModelTypeSet ready_types = ConfigureDataTypes(
+      enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
+      syncer::ModelTypeSet());
+  // Nigori is always downloaded so won't be ready.
+  EXPECT_TRUE(ready_types.Equals(syncer::Difference(
+      syncer::ControlTypes(),
+      syncer::ModelTypeSet(syncer::NIGORI))));
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().HasAll(
       Difference(enabled_types_, syncer::ControlTypes())));
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            enabled_types_).Empty());
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Empty());
 }
 
 TEST_F(SyncBackendHostTest, DisableTypes) {
   // Simulate first time sync.
   InitializeBackend(true);
   fake_manager_->GetAndResetCleanedTypes();
-  ConfigureDataTypes(enabled_types_,
-                     Difference(syncer::ModelTypeSet::All(),
-                                enabled_types_),
-                     syncer::ModelTypeSet());
+  syncer::ModelTypeSet ready_types = ConfigureDataTypes(
+      enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
+      syncer::ModelTypeSet());
+  // Nigori is always downloaded so won't be ready.
+  EXPECT_TRUE(ready_types.Equals(syncer::Difference(
+      syncer::ControlTypes(),
+      syncer::ModelTypeSet(syncer::NIGORI))));
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
       enabled_types_));
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            enabled_types_).Empty());
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Empty());
 
   // Then disable two datatypes.
   syncer::ModelTypeSet disabled_types(syncer::BOOKMARKS,
                                       syncer::SEARCH_ENGINES);
   syncer::ModelTypeSet old_types = enabled_types_;
   enabled_types_.RemoveAll(disabled_types);
-  ConfigureDataTypes(enabled_types_,
-                     Difference(syncer::ModelTypeSet::All(),
-                                enabled_types_),
-                     syncer::ModelTypeSet());
+  ready_types = ConfigureDataTypes(
+      enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
+      syncer::ModelTypeSet());
 
   // Only those datatypes disabled should be cleaned. Nothing should be
   // downloaded.
+  EXPECT_TRUE(ready_types.Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty());
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            old_types).Equals(disabled_types));
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Empty());
 }
 
 TEST_F(SyncBackendHostTest, AddTypes) {
   // Simulate first time sync.
   InitializeBackend(true);
   fake_manager_->GetAndResetCleanedTypes();
-  ConfigureDataTypes(enabled_types_,
-                     Difference(syncer::ModelTypeSet::All(),
-                                enabled_types_),
-                     syncer::ModelTypeSet());
+  syncer::ModelTypeSet ready_types = ConfigureDataTypes(
+      enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
+      syncer::ModelTypeSet());
+  // Nigori is always downloaded so won't be ready.
+  EXPECT_TRUE(ready_types.Equals(syncer::Difference(
+      syncer::ControlTypes(),
+      syncer::ModelTypeSet(syncer::NIGORI))));
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
       enabled_types_));
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            enabled_types_).Empty());
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Empty());
 
   // Then add two datatypes.
   syncer::ModelTypeSet new_types(syncer::EXTENSIONS,
                                  syncer::APPS);
   enabled_types_.PutAll(new_types);
-  ConfigureDataTypes(enabled_types_,
-                     Difference(syncer::ModelTypeSet::All(),
-                                enabled_types_),
-                     syncer::ModelTypeSet());
+  ready_types = ConfigureDataTypes(
+      enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
+      syncer::ModelTypeSet());
 
   // Only those datatypes added should be downloaded (plus nigori). Nothing
   // should be cleaned aside from the disabled types.
-  EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
-      Union(new_types, syncer::ModelTypeSet(syncer::NIGORI))));
+  new_types.Put(syncer::NIGORI);
+  EXPECT_TRUE(
+      ready_types.Equals(syncer::Difference(enabled_types_, new_types)));
+  EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(new_types));
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            enabled_types_).Empty());
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Empty());
 }
 
 // And and disable in the same configuration.
 TEST_F(SyncBackendHostTest, AddDisableTypes) {
   // Simulate first time sync.
   InitializeBackend(true);
   fake_manager_->GetAndResetCleanedTypes();
-  ConfigureDataTypes(enabled_types_,
-                     Difference(syncer::ModelTypeSet::All(),
-                                enabled_types_),
-                     syncer::ModelTypeSet());
+  syncer::ModelTypeSet ready_types = ConfigureDataTypes(
+      enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
+      syncer::ModelTypeSet());
+  // Nigori is always downloaded so won't be ready.
+  EXPECT_TRUE(ready_types.Equals(syncer::Difference(
+      syncer::ControlTypes(),
+      syncer::ModelTypeSet(syncer::NIGORI))));
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
       enabled_types_));
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            enabled_types_).Empty());
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Empty());
 
   // Then add two datatypes.
   syncer::ModelTypeSet old_types = enabled_types_;
   syncer::ModelTypeSet disabled_types(syncer::BOOKMARKS,
                                       syncer::SEARCH_ENGINES);
   syncer::ModelTypeSet new_types(syncer::EXTENSIONS,
                                  syncer::APPS);
   enabled_types_.PutAll(new_types);
   enabled_types_.RemoveAll(disabled_types);
-  ConfigureDataTypes(enabled_types_,
-                     Difference(syncer::ModelTypeSet::All(),
-                                enabled_types_),
-                     syncer::ModelTypeSet());
+  ready_types = ConfigureDataTypes(
+      enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
+      syncer::ModelTypeSet());
 
   // Only those datatypes added should be downloaded (plus nigori). Nothing
   // should be cleaned aside from the disabled types.
-  EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
-      Union(new_types, syncer::ModelTypeSet(syncer::NIGORI))));
+  new_types.Put(syncer::NIGORI);
+  EXPECT_TRUE(
+      ready_types.Equals(syncer::Difference(enabled_types_, new_types)));
+  EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(new_types));
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            old_types).Equals(disabled_types));
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       old_types).Equals(disabled_types));
 }
 
 // Test restarting the browser to newly supported datatypes. The new datatypes
 // should be downloaded on the configuration after backend initialization.
@@ skipping 10 matching lines @@
 
   // Does nothing.
   InitializeBackend(true);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty());
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            old_types).Empty());
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(old_types));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Equals(new_types));
 
-  // Downloads and applies the new types.
-  ConfigureDataTypes(enabled_types_,
-                     Difference(syncer::ModelTypeSet::All(),
-                                enabled_types_),
-                     syncer::ModelTypeSet());
-  EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
-      Union(new_types, syncer::ModelTypeSet(syncer::NIGORI))));
+  // Downloads and applies the new types (plus nigori).
+  syncer::ModelTypeSet ready_types = ConfigureDataTypes(
+      enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
+      syncer::ModelTypeSet());
+
+  new_types.Put(syncer::NIGORI);
+  EXPECT_TRUE(ready_types.Equals(
+      syncer::Difference(old_types, syncer::ModelTypeSet(syncer::NIGORI))));
+  EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(new_types));
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            enabled_types_).Empty());
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
   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
@@ skipping 19 matching lines @@
       syncer::ModelTypeSet(syncer::NIGORI)));
   EXPECT_TRUE(fake_manager_->GetAndResetCleanedTypes().HasAll(partial_types));
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(
       syncer::Union(full_types, syncer::ModelTypeSet(syncer::NIGORI))));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Equals(Union(new_types, Difference(
                       partial_types, syncer::ModelTypeSet(syncer::NIGORI)))));
 
   // Downloads and applies the new types and partial types (which includes
   // nigori anyways).
-  ConfigureDataTypes(enabled_types_,
-                     Difference(syncer::ModelTypeSet::All(),
-                                enabled_types_),
-                     syncer::ModelTypeSet());
+  syncer::ModelTypeSet ready_types = ConfigureDataTypes(
+      enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
+      syncer::ModelTypeSet());
+  EXPECT_TRUE(ready_types.Equals(full_types));
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(
       Union(new_types, partial_types)));
   EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(),
                            enabled_types_).Empty());
   EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_));
   EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       enabled_types_).Empty());
 }
 
@@ skipping 110 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
 // SyncBackendHost needs to tell the manager to purge the type, even though
 // it's already disabled (crbug.com/386778).
 TEST_F(SyncBackendHostTest, DisableThenPurgeType) {
   syncer::ModelTypeSet error_types(syncer::BOOKMARKS);
 
   InitializeBackend(true);
 
   // First enable the types.
-  ConfigureDataTypes(enabled_types_,
-                     Difference(syncer::ModelTypeSet::All(),
-                                enabled_types_),
-                     syncer::ModelTypeSet());
+  syncer::ModelTypeSet ready_types = ConfigureDataTypes(
+      enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
+      syncer::ModelTypeSet());
+
+  // Nigori is always downloaded so won't be ready.
+  EXPECT_TRUE(ready_types.Equals(syncer::Difference(
+      syncer::ControlTypes(),
+      syncer::ModelTypeSet(syncer::NIGORI))));
 
   // Then mark the error types as unready (disables without purging).
-  ConfigureDataTypes(enabled_types_,
-                     Difference(syncer::ModelTypeSet::All(),
-                                enabled_types_),
-                     error_types);
+  ready_types = ConfigureDataTypes(
+      enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
+      error_types);
+  EXPECT_TRUE(
+      ready_types.Equals(syncer::Difference(enabled_types_, error_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);
-  ConfigureDataTypes(enabled_types_,
-                     Difference(syncer::ModelTypeSet::All(),
-                                enabled_types_),
-                     syncer::ModelTypeSet());
+  ready_types = ConfigureDataTypes(
+      enabled_types_, Difference(syncer::ModelTypeSet::All(), enabled_types_),
+      syncer::ModelTypeSet());
+  EXPECT_TRUE(
+      ready_types.Equals(syncer::Difference(enabled_types_, error_types)));
   EXPECT_FALSE(fake_manager_->GetTypesWithEmptyProgressMarkerToken(
       error_types).Empty());
 }
 
 }  // namespace
 
 }  // namespace browser_sync