[Sync] Have SBH tell SyncManager which types to purge

sync/internal_api/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 "sync/internal_api/sync_manager_impl.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 281 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,
-    ModelTypeSet to_ignore,
     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(!retry_task.is_null());
 
-  // Cleanup any types that might have just been disabled.
-  ModelTypeSet previous_types = ModelTypeSet::All();
-  if (!session_context_->routing_info().empty())
-    previous_types = GetRoutingInfoTypes(session_context_->routing_info());
-
-  // By removing the |to_ignore| types from the previous types, they won't be
-  // treated as disabled, and therefore won't be purged.
-  previous_types.RemoveAll(to_ignore);
-
   DVLOG(1) << "Configuring -"
+           << "\n\t" << "current types: "
+           << ModelTypeSetToString(GetRoutingInfoTypes(new_routing_info))
            << "\n\t" << "types to download: "
            << ModelTypeSetToString(to_download)
-           << "\n\t" << "current types: "
-           << ModelTypeSetToString(GetRoutingInfoTypes(new_routing_info))
-           << "\n\t" << "previous types: "
-           << ModelTypeSetToString(previous_types)
-           << "\n\t" << "to_journal: "
+           << "\n\t" << "types to purge: "
+           << ModelTypeSetToString(to_purge)
+           << "\n\t" << "types to journal: "
            << ModelTypeSetToString(to_journal)
-           << "\n\t" << "to_unapply: "
-           << ModelTypeSetToString(to_unapply)
-           << "\n\t" << "to_ignore: "
-           << ModelTypeSetToString(to_ignore);
-  if (!PurgeDisabledTypes(previous_types,
-                          GetRoutingInfoTypes(new_routing_info),
+           << "\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;
   }
 
   ConfigurationParams params(GetSourceFromReason(reason),
@@ skipping 248 matching lines @@
   UMA_HISTOGRAM_COUNTS("Sync.PartiallySyncedTypes",
                        partially_synced_types.Size());
   if (partially_synced_types.Empty())
     return true;
   return directory()->PurgeEntriesWithTypeIn(partially_synced_types,
                                              ModelTypeSet(),
                                              ModelTypeSet());
 }
 
 bool SyncManagerImpl::PurgeDisabledTypes(
-    ModelTypeSet previously_enabled_types,
-    ModelTypeSet currently_enabled_types,
+    ModelTypeSet to_purge,
     ModelTypeSet to_journal,
     ModelTypeSet to_unapply) {
-  ModelTypeSet disabled_types = Difference(previously_enabled_types,
-                                           currently_enabled_types);
-  if (disabled_types.Empty())
+  if (to_purge.Empty())
     return true;
-  DVLOG(1) << "Purging disabled types "
-           << ModelTypeSetToString(disabled_types);
-  DCHECK(disabled_types.HasAll(to_journal));
-  DCHECK(disabled_types.HasAll(to_unapply));
-  return directory()->PurgeEntriesWithTypeIn(disabled_types,
-                                             to_journal,
-                                             to_unapply);
+  DVLOG(1) << "Purging disabled types " << ModelTypeSetToString(to_purge);
+  DCHECK(to_purge.HasAll(to_journal));
+  DCHECK(to_purge.HasAll(to_unapply));
+  return directory()->PurgeEntriesWithTypeIn(to_purge, to_journal, to_unapply);
 }
 
 void SyncManagerImpl::UpdateCredentials(const SyncCredentials& credentials) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(initialized_);
   DCHECK(!credentials.email.empty());
   DCHECK(!credentials.sync_token.empty());
 
   observing_network_connectivity_changes_ = true;
   if (!connection_manager_->SetAuthToken(credentials.sync_token,
@@ skipping 788 matching lines @@
 int SyncManagerImpl::GetDefaultNudgeDelay() {
   return kDefaultNudgeDelayMilliseconds;
 }
 
 // static.
 int SyncManagerImpl::GetPreferencesNudgeDelay() {
   return kPreferencesNudgeDelayMilliseconds;
 }
 
 }  // namespace syncer