[Sync] Separate purge types step from sync manager configuration.

components/sync/driver/glue/sync_backend_host_core.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_core.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
@@ skipping 84 matching lines @@
       restored_keystore_key_for_bootstrapping(
           restored_keystore_key_for_bootstrapping),
       engine_components_factory(std::move(engine_components_factory)),
       unrecoverable_error_handler(unrecoverable_error_handler),
       report_unrecoverable_error_function(report_unrecoverable_error_function),
       saved_nigori_state(std::move(saved_nigori_state)),
       invalidation_versions(invalidation_versions) {}
 
 DoInitializeOptions::~DoInitializeOptions() {}
 
-DoConfigureSyncerTypes::DoConfigureSyncerTypes() {}
-
-DoConfigureSyncerTypes::DoConfigureSyncerTypes(
-    const DoConfigureSyncerTypes& other) = default;
-
-DoConfigureSyncerTypes::~DoConfigureSyncerTypes() {}
-
 SyncBackendHostCore::SyncBackendHostCore(
     const std::string& name,
     const base::FilePath& sync_data_folder_path,
     const base::WeakPtr<SyncBackendHostImpl>& backend)
     : name_(name),
       sync_data_folder_path_(sync_data_folder_path),
       host_(backend),
       weak_ptr_factory_(this) {
   DCHECK(backend.get());
   // This is constructed on the UI thread but used from the sync thread.
@@ skipping 73 matching lines @@
   ModelTypeSet new_control_types =
       registrar_->ConfigureDataTypes(ControlTypes(), ModelTypeSet());
   ModelSafeRoutingInfo routing_info;
   registrar_->GetModelSafeRoutingInfo(&routing_info);
   SDVLOG(1) << "Control Types " << ModelTypeSetToString(new_control_types)
             << " added; calling ConfigureSyncer";
 
   ModelTypeSet types_to_purge =
       Difference(ModelTypeSet::All(), GetRoutingInfoTypes(routing_info));
 
+  sync_manager_->PurgeDisabledTypes(types_to_purge, ModelTypeSet(),
+                                    ModelTypeSet());
   sync_manager_->ConfigureSyncer(
-      reason, new_control_types, types_to_purge, ModelTypeSet(), ModelTypeSet(),
-      routing_info,
+      reason, new_control_types, routing_info,
       base::Bind(&SyncBackendHostCore::DoInitialProcessControlTypes,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Closure());
 }
 
 void SyncBackendHostCore::OnConnectionStatusChange(ConnectionStatus status) {
   DCHECK(thread_checker_.CalledOnValidThread());
   host_.Call(FROM_HERE,
              &SyncBackendHostImpl::HandleConnectionStatusChangeOnFrontendLoop,
              status);
@@ skipping 329 matching lines @@
       this);
   if (sync_manager_) {
     DisableDirectoryTypeDebugInfoForwarding();
     save_changes_timer_.reset();
     sync_manager_->RemoveObserver(this);
     sync_manager_->ShutdownOnSyncThread(reason);
     sync_manager_.reset();
   }
 }
 
+void SyncBackendHostCore::DoPurgeDisabledTypes(const ModelTypeSet& to_purge,
+                                               const ModelTypeSet& to_journal,
+                                               const ModelTypeSet& to_unapply) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  sync_manager_->PurgeDisabledTypes(to_purge, to_journal, to_unapply);
+}
+
 void SyncBackendHostCore::DoConfigureSyncer(
     ConfigureReason reason,
-    const DoConfigureSyncerTypes& config_types,
+    const ModelTypeSet& to_download,
     const ModelSafeRoutingInfo routing_info,
     const base::Callback<void(ModelTypeSet, ModelTypeSet)>& ready_task,
     const base::Closure& retry_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!ready_task.is_null());
   DCHECK(!retry_callback.is_null());
-  base::Closure chained_ready_task(base::Bind(
-      &SyncBackendHostCore::DoFinishConfigureDataTypes,
-      weak_ptr_factory_.GetWeakPtr(), config_types.to_download, ready_task));
+  base::Closure chained_ready_task(
+      base::Bind(&SyncBackendHostCore::DoFinishConfigureDataTypes,
+                 weak_ptr_factory_.GetWeakPtr(), to_download, ready_task));
   base::Closure chained_retry_task(
       base::Bind(&SyncBackendHostCore::DoRetryConfiguration,
                  weak_ptr_factory_.GetWeakPtr(), retry_callback));
-  sync_manager_->ConfigureSyncer(reason, config_types.to_download,
-                                 config_types.to_purge, config_types.to_journal,
-                                 config_types.to_unapply, routing_info,
+  sync_manager_->ConfigureSyncer(reason, to_download, routing_info,
                                  chained_ready_task, chained_retry_task);
 }
 
 void SyncBackendHostCore::DoFinishConfigureDataTypes(
     ModelTypeSet types_to_config,
     const base::Callback<void(ModelTypeSet, ModelTypeSet)>& ready_task) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Update the enabled types for the bridge and sync manager.
   ModelSafeRoutingInfo routing_info;
@@ skipping 104 matching lines @@
 }
 
 void SyncBackendHostCore::ClearServerDataDone(
     const base::Closure& frontend_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   host_.Call(FROM_HERE, &SyncBackendHostImpl::ClearServerDataDoneOnFrontendLoop,
              frontend_callback);
 }
 
 }  // namespace syncer