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

components/sync/driver/glue/sync_backend_host_impl.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 <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 348 matching lines @@
   // - Types which have just been added to the routing info (types_to_download):
   //   are downloaded.
   // - Types which have encountered a fatal error (fatal_types) are deleted
   //   from the directory and journaled in the delete journal.
   // - Types which have encountered a cryptographer error (crypto_types) are
   //   unapplied (local state is purged but sync state is not).
   // - All other types not in the routing info (types just disabled) are deleted
   //   from the directory.
   // - Everything else (enabled types and already disabled types) is not
   //   touched.
-  RequestConfigureSyncer(reason, types_to_download, types_to_purge, fatal_types,
-                         unapply_types, inactive_types, routing_info,
-                         ready_task, retry_callback);
+  sync_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&SyncBackendHostCore::DoPurgeDisabledTypes, core_,
+                            types_to_purge, fatal_types, unapply_types));
+  RequestConfigureSyncer(reason, types_to_download, routing_info, ready_task,
+                         retry_callback);
 
   DCHECK(Intersection(active_types, types_to_purge).Empty());
   DCHECK(Intersection(active_types, fatal_types).Empty());
   DCHECK(Intersection(active_types, unapply_types).Empty());
   DCHECK(Intersection(active_types, inactive_types).Empty());
   return Difference(active_types, types_to_download);
 }
 
 void SyncBackendHostImpl::EnableEncryptEverything() {
   sync_task_runner_->PostTask(
@@ skipping 110 matching lines @@
 void SyncBackendHostImpl::InitCore(
     std::unique_ptr<DoInitializeOptions> options) {
   sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoInitialize, core_,
                             base::Passed(&options)));
 }
 
 void SyncBackendHostImpl::RequestConfigureSyncer(
     ConfigureReason reason,
     ModelTypeSet to_download,
-    ModelTypeSet to_purge,
-    ModelTypeSet to_journal,
-    ModelTypeSet to_unapply,
-    ModelTypeSet to_ignore,
     const ModelSafeRoutingInfo& routing_info,
     const base::Callback<void(ModelTypeSet, ModelTypeSet)>& ready_task,
     const base::Closure& retry_callback) {
-  DoConfigureSyncerTypes config_types;
-  config_types.to_download = to_download;
-  config_types.to_purge = to_purge;
-  config_types.to_journal = to_journal;
-  config_types.to_unapply = to_unapply;
   sync_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncBackendHostCore::DoConfigureSyncer, core_, reason,
-                 config_types, routing_info, ready_task, retry_callback));
+                 to_download, routing_info, ready_task, retry_callback));
 }
 
 void SyncBackendHostImpl::FinishConfigureDataTypesOnFrontendLoop(
     const ModelTypeSet enabled_types,
     const ModelTypeSet succeeded_configuration_types,
     const ModelTypeSet failed_configuration_types,
     const base::Callback<void(ModelTypeSet, ModelTypeSet)>& ready_task) {
   if (invalidator_) {
     CHECK(invalidator_->UpdateRegisteredInvalidationIds(
         this, ModelTypeSetToObjectIdSet(enabled_types)));
@@ skipping 235 matching lines @@
     const SyncManager::ClearServerDataCallback& frontend_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   frontend_callback.Run();
 }
 
 }  // namespace syncer
 
 #undef SDVLOG
 
 #undef SLOG