[Sync] Move ConfigureDataTypes logic into DataTypeManagerImpl.

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 17 matching lines @@
 #include "components/sync/device_info/device_info.h"
 #include "components/sync/driver/fake_sync_client.h"
 #include "components/sync/engine/cycle/commit_counters.h"
 #include "components/sync/engine/cycle/status_counters.h"
 #include "components/sync/engine/cycle/update_counters.h"
 #include "components/sync/engine/fake_sync_manager.h"
 #include "components/sync/engine/model_safe_worker.h"
 #include "components/sync/engine/net/http_bridge_network_resources.h"
 #include "components/sync/engine/net/network_resources.h"
 #include "components/sync/engine/passive_model_worker.h"
-#include "components/sync/engine/sync_engine_host.h"
+#include "components/sync/engine/sync_engine_host_stub.h"
 #include "components/sync/engine/sync_manager_factory.h"
 #include "components/sync/test/callback_counter.h"
 #include "components/sync_preferences/pref_service_syncable.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "google/cacheinvalidation/include/types.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 11 matching lines @@
     FILE_PATH_LITERAL("sync-test");
 
 ACTION_P(Signal, event) {
   event->Signal();
 }
 
 void EmptyNetworkTimeUpdate(const base::Time&,
                             const base::TimeDelta&,
                             const base::TimeDelta&) {}
 
-void QuitMessageLoop() {
-  base::MessageLoop::current()->QuitWhenIdle();
-}
+class TestSyncEngineHost : public SyncEngineHostStub {
+ public:
+  explicit TestSyncEngineHost(
+      base::Callback<void(ModelTypeSet)> set_engine_types)
+      : set_engine_types_(set_engine_types) {}
 
-class MockSyncEngineHost : public SyncEngineHost {
- public:
-  virtual ~MockSyncEngineHost() {}
+  void OnEngineInitialized(ModelTypeSet initial_types,
+                           const WeakHandle<JsBackend>&,
+                           const WeakHandle<DataTypeDebugInfoListener>&,
+                           const std::string&,
+                           bool success) override {
+    EXPECT_EQ(expect_success_, success);
+    set_engine_types_.Run(initial_types);
+    base::MessageLoop::current()->QuitWhenIdle();
+  }
 
-  MOCK_METHOD5(OnEngineInitialized,
-               void(ModelTypeSet initial_types,
-                    const WeakHandle<JsBackend>&,
-                    const WeakHandle<DataTypeDebugInfoListener>&,
-                    const std::string&,
-                    bool));
-  MOCK_METHOD0(OnSyncCycleCompleted, void());
-  MOCK_METHOD1(OnConnectionStatusChange, void(ConnectionStatus status));
-  MOCK_METHOD0(OnClearServerDataSucceeded, void());
-  MOCK_METHOD0(OnClearServerDataFailed, void());
-  MOCK_METHOD2(OnPassphraseRequired,
-               void(PassphraseRequiredReason, const sync_pb::EncryptedData&));
-  MOCK_METHOD0(OnPassphraseAccepted, void());
-  MOCK_METHOD2(OnEncryptedTypesChanged, void(ModelTypeSet, bool));
-  MOCK_METHOD0(OnEncryptionComplete, void());
-  MOCK_METHOD1(OnMigrationNeededForTypes, void(ModelTypeSet));
-  MOCK_METHOD1(OnProtocolEvent, void(const ProtocolEvent&));
-  MOCK_METHOD2(OnDirectoryTypeCommitCounterUpdated,
-               void(ModelType, const CommitCounters&));
-  MOCK_METHOD2(OnDirectoryTypeUpdateCounterUpdated,
-               void(ModelType, const UpdateCounters&));
-  MOCK_METHOD2(OnDatatypeStatusCounterUpdated,
-               void(ModelType, const StatusCounters&));
-  MOCK_METHOD1(OnExperimentsChanged, void(const Experiments&));
-  MOCK_METHOD1(OnActionableError, void(const SyncProtocolError& sync_error));
-  MOCK_METHOD0(OnSyncConfigureRetry, void());
-  MOCK_METHOD1(OnLocalSetPassphraseEncryption,
-               void(const SyncEncryptionHandler::NigoriState& nigori_state));
+  void SetExpectSuccess(bool expect_success) {
+    expect_success_ = expect_success;
+  }
+
+ private:
+  base::Callback<void(ModelTypeSet)> set_engine_types_;
+  bool expect_success_ = false;
 };
 
 class FakeSyncManagerFactory : public SyncManagerFactory {
  public:
   explicit FakeSyncManagerFactory(FakeSyncManager** fake_manager)
       : fake_manager_(fake_manager) {
     *fake_manager_ = nullptr;
   }
   ~FakeSyncManagerFactory() override {}
 
@@ skipping 34 matching lines @@
         return new PassiveModelWorker();
       default:
         return nullptr;
     }
   }
 };
 
 class SyncEngineTest : public testing::Test {
  protected:
   SyncEngineTest()
-      : sync_thread_("SyncThreadForTest"), fake_manager_(nullptr) {}
+      : sync_thread_("SyncThreadForTest"),
+        host_(base::Bind(&SyncEngineTest::SetEngineTypes,
+                         base::Unretained(this))),
+        fake_manager_(nullptr) {}
 
   ~SyncEngineTest() override {}
 
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     SyncPrefs::RegisterProfilePrefs(pref_service_.registry());
 
     sync_prefs_ = base::MakeUnique<SyncPrefs>(&pref_service_);
     sync_thread_.StartAndWaitForTesting();
@@ skipping 28 matching lines @@
       backend_->Shutdown(STOP_SYNC);
     }
     backend_.reset();
     sync_prefs_.reset();
     // Pump messages posted by the sync thread.
     base::RunLoop().RunUntilIdle();
   }
 
   // Synchronously initializes the backend.
   void InitializeBackend(bool expect_success) {
-    EXPECT_CALL(mock_host_, OnEngineInitialized(_, _, _, _, expect_success))
-        .WillOnce(InvokeWithoutArgs(QuitMessageLoop));
+    host_.SetExpectSuccess(expect_success);
     SyncEngine::HttpPostProviderFactoryGetter
         http_post_provider_factory_getter =
             base::Bind(&NetworkResources::GetHttpPostProviderFactory,
                        base::Unretained(network_resources_.get()), nullptr,
                        base::Bind(&EmptyNetworkTimeUpdate));
 
     SyncEngine::InitParams params;
     params.sync_task_runner = sync_thread_.task_runner();
-    params.host = &mock_host_;
+    params.host = &host_;
     params.registrar = base::MakeUnique<SyncBackendRegistrar>(
         std::string(), base::Bind(&SyncClient::CreateModelWorkerForGroup,
                                   base::Unretained(&sync_client_)));
     params.http_factory_getter = http_post_provider_factory_getter;
     params.credentials = credentials_;
     params.sync_manager_factory = std::move(fake_manager_factory_);
     params.delete_sync_data_folder = true;
     params.unrecoverable_error_handler =
         MakeWeakHandle(test_unrecoverable_error_handler_.GetWeakPtr()),
     params.saved_nigori_state = std::move(saved_nigori_state_);
     sync_prefs_->GetInvalidationVersions(&params.invalidation_versions);
 
     backend_->Initialize(std::move(params));
 
-    base::RunLoop run_loop;
-    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-        FROM_HERE, run_loop.QuitClosure(), TestTimeouts::action_timeout());
-    run_loop.Run();
+    PumpSyncThread();
     // |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_);
   }
 
-  // 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, enabled_types_,
-        &config_state_map);
-    ModelTypeConfigurer::SetDataTypesState(
-        ModelTypeConfigurer::DISABLED,
-        Difference(ModelTypeSet::All(), enabled_types_), &config_state_map);
-    return config_state_map;
+  // Synchronously configures the backend's datatypes.
+  ModelTypeSet ConfigureDataTypes() {
+    return ConfigureDataTypesWithUnready(ModelTypeSet());
   }
 
-  // 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();
+  ModelTypeSet ConfigureDataTypesWithUnready(ModelTypeSet unready_types) {
+    ModelTypeSet disabled_types =
+        Difference(ModelTypeSet::All(), enabled_types_);
+
+    ModelTypeConfigurer::ConfigureParams params;
+    params.reason = CONFIGURE_REASON_RECONFIGURATION;
+    params.enabled_types = Difference(enabled_types_, unready_types);
+    params.disabled_types = Union(disabled_types, unready_types);
+    params.to_download = Difference(params.enabled_types, engine_types_);
+    if (!params.to_download.Empty()) {
+      params.to_download.Put(NIGORI);
+    }
+    params.to_purge = Intersection(engine_types_, disabled_types);
+    params.ready_task =
+        base::Bind(&SyncEngineTest::DownloadReady, base::Unretained(this));
+    params.retry_callback =
+        base::Bind(&SyncEngineTest::OnDownloadRetry, base::Unretained(this));
+
+    ModelTypeSet ready_types =
+        Difference(params.enabled_types, params.to_download);
+    backend_->ConfigureDataTypes(std::move(params));
+    PumpSyncThread();
+
     return ready_types;
   }
 
  protected:
   void DownloadReady(ModelTypeSet succeeded_types, ModelTypeSet failed_types) {
+    engine_types_.PutAll(succeeded_types);
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
   void OnDownloadRetry() { NOTIMPLEMENTED(); }
 
+  void SetEngineTypes(ModelTypeSet engine_types) {
+    EXPECT_TRUE(engine_types_.Empty());
+    engine_types_ = engine_types;
+  }
+
+  void PumpSyncThread() {
+    base::RunLoop run_loop;
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE, run_loop.QuitClosure(), TestTimeouts::action_timeout());
+    run_loop.Run();
+  }
+
   base::MessageLoop message_loop_;
   base::ScopedTempDir temp_dir_;
   sync_preferences::TestingPrefServiceSyncable pref_service_;
   base::Thread sync_thread_;
-  StrictMock<MockSyncEngineHost> mock_host_;
+  TestSyncEngineHost host_;
   SyncCredentials credentials_;
   BackendSyncClient sync_client_;
   TestUnrecoverableErrorHandler test_unrecoverable_error_handler_;
   std::unique_ptr<SyncPrefs> sync_prefs_;
   std::unique_ptr<SyncBackendHostImpl> backend_;
   std::unique_ptr<FakeSyncManagerFactory> fake_manager_factory_;
   FakeSyncManager* fake_manager_;
+  ModelTypeSet engine_types_;
   ModelTypeSet enabled_types_;
   std::unique_ptr<NetworkResources> network_resources_;
   std::unique_ptr<SyncEncryptionHandler::NigoriState> saved_nigori_state_;
 };
 
 // Test basic initialization with no initial types (first time initialization).
 // Only the nigori should be configured.
 TEST_F(SyncEngineTest, InitShutdown) {
   InitializeBackend(true);
   EXPECT_EQ(ControlTypes(), fake_manager_->GetAndResetDownloadedTypes());
   EXPECT_EQ(ControlTypes(), fake_manager_->InitialSyncEndedTypes());
   EXPECT_TRUE(
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(ControlTypes())
           .Empty());
 }
 
 // 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(ConfigStateMapForEnabledTypes());
+  ModelTypeSet ready_types = ConfigureDataTypes();
   // 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_->GetAndResetPurgedTypes(), enabled_types_)
           .Empty());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_TRUE(
       fake_manager_->GetTypesWithEmptyProgressMarkerToken(enabled_types_)
           .Empty());
 
-  ModelTypeSet ready_types =
-      ConfigureDataTypes(ConfigStateMapForEnabledTypes());
+  ModelTypeSet ready_types = ConfigureDataTypes();
   EXPECT_EQ(enabled_types_, ready_types);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty());
   EXPECT_TRUE(
       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());
@@ skipping 15 matching lines @@
   InitializeBackend(true);
   EXPECT_EQ(ModelTypeSet(NIGORI), fake_manager_->GetAndResetDownloadedTypes());
   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(ConfigStateMapForEnabledTypes());
+  ModelTypeSet ready_types = ConfigureDataTypes();
   EXPECT_EQ(full_types, ready_types);
   EXPECT_TRUE(
       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());
@@ skipping 12 matching lines @@
             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_->GetAndResetPurgedTypes();
 
   // The actual configuration should redownload and apply all the enabled types.
-  ModelTypeSet ready_types =
-      ConfigureDataTypes(ConfigStateMapForEnabledTypes());
+  ModelTypeSet ready_types = ConfigureDataTypes();
   // 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_->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_->GetAndResetPurgedTypes();
-  ModelTypeSet ready_types =
-      ConfigureDataTypes(ConfigStateMapForEnabledTypes());
+  ModelTypeSet ready_types = ConfigureDataTypes();
   // 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_->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(ConfigStateMapForEnabledTypes());
+  ready_types = ConfigureDataTypes();
 
   // 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_->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_->GetAndResetPurgedTypes();
-  ModelTypeSet ready_types =
-      ConfigureDataTypes(ConfigStateMapForEnabledTypes());
+  ModelTypeSet ready_types = ConfigureDataTypes();
   // 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_->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(ConfigStateMapForEnabledTypes());
+  ready_types = ConfigureDataTypes();
 
   // 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_->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_->GetAndResetPurgedTypes();
-  ModelTypeSet ready_types =
-      ConfigureDataTypes(ConfigStateMapForEnabledTypes());
+  ModelTypeSet ready_types = ConfigureDataTypes();
   // 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_->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(ConfigStateMapForEnabledTypes());
+  ready_types = ConfigureDataTypes();
 
   // 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_->GetAndResetPurgedTypes(), old_types));
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetEnabledTypes());
@@ skipping 16 matching lines @@
   // Does nothing.
   InitializeBackend(true);
   EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().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(ConfigStateMapForEnabledTypes());
+  ModelTypeSet ready_types = ConfigureDataTypes();
 
   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_->GetAndResetPurgedTypes(), enabled_types_)
           .Empty());
   EXPECT_EQ(enabled_types_, fake_manager_->InitialSyncEndedTypes());
   EXPECT_EQ(enabled_types_, fake_manager_->GetAndResetEnabledTypes());
   EXPECT_TRUE(
@@ skipping 22 matching lines @@
   EXPECT_EQ(ModelTypeSet(NIGORI), fake_manager_->GetAndResetDownloadedTypes());
   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(ConfigStateMapForEnabledTypes());
+  ModelTypeSet ready_types = ConfigureDataTypes();
   EXPECT_EQ(full_types, ready_types);
   EXPECT_EQ(Union(new_types, partial_types),
             fake_manager_->GetAndResetDownloadedTypes());
   EXPECT_TRUE(
       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_)
@@ skipping 86 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(ConfigStateMapForEnabledTypes());
+  ModelTypeSet ready_types = ConfigureDataTypes();
 
   // 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).
-  ModelTypeConfigurer::DataTypeConfigStateMap config_state_map =
-      ConfigStateMapForEnabledTypes();
-  ModelTypeConfigurer::SetDataTypesState(ModelTypeConfigurer::UNREADY,
-                                         error_types, &config_state_map);
-  ready_types = ConfigureDataTypes(config_state_map);
+  ready_types = ConfigureDataTypesWithUnready(error_types);
   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(ConfigStateMapForEnabledTypes());
+  ready_types = ConfigureDataTypes();
   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