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

components/sync/engine_impl/sync_manager_impl.cc

 // Copyright (c) 2012 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/engine_impl/sync_manager_impl.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 166 matching lines @@
 
     if (marker.token().empty())
       result.Put(i.Get());
   }
   return result;
 }
 
 void SyncManagerImpl::ConfigureSyncer(
     ConfigureReason reason,
     ModelTypeSet to_download,
-    ModelTypeSet to_purge,
-    ModelTypeSet to_journal,
-    ModelTypeSet to_unapply,
     const ModelSafeRoutingInfo& new_routing_info,
     const base::Closure& ready_task,
     const base::Closure& retry_task) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!ready_task.is_null());
   DCHECK(initialized_);
 
   // Don't download non-blocking types that have already completed initial sync.
   to_download.RemoveAll(
       model_type_registry_->GetInitialSyncDoneNonBlockingTypes());
 
   DVLOG(1) << "Configuring -"
            << "\n\t"
            << "current types: "
            << ModelTypeSetToString(GetRoutingInfoTypes(new_routing_info))
            << "\n\t"
-           << "types to download: " << ModelTypeSetToString(to_download)
-           << "\n\t"
-           << "types to purge: " << ModelTypeSetToString(to_purge) << "\n\t"
-           << "types to journal: " << ModelTypeSetToString(to_journal) << "\n\t"
-           << "types to unapply: " << ModelTypeSetToString(to_unapply);
-  if (!PurgeDisabledTypes(to_purge, to_journal, to_unapply)) {
-    // We failed to cleanup the types. Invoke the ready task without actually
-    // configuring any types. The caller should detect this as a configuration
-    // failure and act appropriately.
-    ready_task.Run();
-    return;
-  }
-
+           << "types to download: " << ModelTypeSetToString(to_download);
   ConfigurationParams params(GetSourceFromReason(reason), to_download,
                              new_routing_info, ready_task, retry_task);
 
   scheduler_->Start(SyncScheduler::CONFIGURATION_MODE, base::Time());
   scheduler_->ScheduleConfiguration(params);
 }
 
 void SyncManagerImpl::Init(InitArgs* args) {
   CHECK(!initialized_);
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 224 matching lines @@
   // re-downloaded during any configuration. But, it's possible for a datatype
   // to have a progress marker but not have initial sync ended yet, making
   // it a candidate for migration. This is a problem, as the DataTypeManager
   // does not support a migration while it's already in the middle of a
   // configuration. As a result, any partially synced datatype can stall the
   // DTM, waiting for the configuration to complete, which it never will due
   // to the migration error. In addition, a partially synced nigori will
   // trigger the migration logic before the backend is initialized, resulting
   // in crashes. We therefore detect and purge any partially synced types as
   // part of initialization.
-  if (!PurgePartiallySyncedTypes())
-    return false;
-
+  PurgePartiallySyncedTypes();
   return true;
 }
 
-bool SyncManagerImpl::PurgePartiallySyncedTypes() {
+void SyncManagerImpl::PurgePartiallySyncedTypes() {
   ModelTypeSet partially_synced_types = ModelTypeSet::All();
   partially_synced_types.RemoveAll(directory()->InitialSyncEndedTypes());
   partially_synced_types.RemoveAll(
       GetTypesWithEmptyProgressMarkerToken(ModelTypeSet::All()));
 
   DVLOG(1) << "Purging partially synced types "
            << ModelTypeSetToString(partially_synced_types);
   UMA_HISTOGRAM_COUNTS("Sync.PartiallySyncedTypes",
                        partially_synced_types.Size());
-  if (partially_synced_types.Empty())
-    return true;
-  return directory()->PurgeEntriesWithTypeIn(partially_synced_types,
-                                             ModelTypeSet(), ModelTypeSet());
+  directory()->PurgeEntriesWithTypeIn(partially_synced_types, ModelTypeSet(),
+                                      ModelTypeSet());
 }
 
-bool SyncManagerImpl::PurgeDisabledTypes(ModelTypeSet to_purge,
+void SyncManagerImpl::PurgeDisabledTypes(ModelTypeSet to_purge,
                                          ModelTypeSet to_journal,
                                          ModelTypeSet to_unapply) {
-  if (to_purge.Empty())
-    return true;
-  DVLOG(1) << "Purging disabled types " << ModelTypeSetToString(to_purge);
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(initialized_);
+  DVLOG(1) << "Purging disabled types:\n\t"
+           << "types to purge: " << ModelTypeSetToString(to_purge) << "\n\t"
+           << "types to journal: " << ModelTypeSetToString(to_journal) << "\n\t"
+           << "types to unapply: " << ModelTypeSetToString(to_unapply);
   DCHECK(to_purge.HasAll(to_journal));
   DCHECK(to_purge.HasAll(to_unapply));
-  return directory()->PurgeEntriesWithTypeIn(to_purge, to_journal, to_unapply);
+  directory()->PurgeEntriesWithTypeIn(to_purge, to_journal, to_unapply);
 }
 
 void SyncManagerImpl::UpdateCredentials(const SyncCredentials& credentials) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(initialized_);
   DCHECK(!credentials.account_id.empty());
   DCHECK(!credentials.sync_token.empty());
   DCHECK(!credentials.scope_set.empty());
   cycle_context_->set_account_name(credentials.email);
 
@@ skipping 518 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   cycle_context_->set_cookie_jar_mismatch(account_mismatch);
   cycle_context_->set_cookie_jar_empty(empty_jar);
 }
 
 void SyncManagerImpl::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd) {
   directory()->OnMemoryDump(pmd);
 }
 
 }  // namespace syncer