[Sync] Have SBH tell SyncManager which types to purge

chrome/browser/sync/glue/sync_backend_host.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 "build/build_config.h"
 
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 
 #include <algorithm>
 #include <map>
@@ skipping 67 matching lines @@
 using syncer::SyncCredentials;
 
 namespace {
 
 // Helper struct to handle currying params to
 // SyncBackendHost::Core::DoConfigureSyncer.
 struct DoConfigureSyncerTypes {
   DoConfigureSyncerTypes() {}
   ~DoConfigureSyncerTypes() {}
   syncer::ModelTypeSet to_download;
+  syncer::ModelTypeSet to_purge;
   syncer::ModelTypeSet to_journal;
   syncer::ModelTypeSet to_unapply;
-  syncer::ModelTypeSet to_ignore;
 };
 
 }  // namespace
 
 // Helper macros to log with the syncer thread name; useful when there
 // are multiple syncers involved.
 
 #define SLOG(severity) LOG(severity) << name_ << ": "
 
 #define SDVLOG(verbose_level) DVLOG(verbose_level) << name_ << ": "
@@ skipping 609 matching lines @@
   // must ask the syncer to download them.  Any newly supported datatypes will
   // not have been in that routing info list, so they will be among the types
   // downloaded if they are enabled.
   //
   // The SyncBackendRegistrar's state was initially derived from the types
   // detected to have been downloaded in the database.  Afterwards it is
   // modified only by this function.  We expect it to remain in sync with the
   // backend because configuration requests are never aborted; they are retried
   // until they succeed or the backend is shut down.
 
+  syncer::ModelTypeSet previous_types = registrar_->GetLastConfiguredTypes();
+
   syncer::ModelTypeSet disabled_types =
       GetDataTypesInState(DISABLED, config_state_map);
   syncer::ModelTypeSet fatal_types =
       GetDataTypesInState(FATAL, config_state_map);
   syncer::ModelTypeSet crypto_types =
       GetDataTypesInState(CRYPTO, config_state_map);
   disabled_types.PutAll(fatal_types);
   disabled_types.PutAll(crypto_types);
   syncer::ModelTypeSet types_to_download = registrar_->ConfigureDataTypes(
       GetDataTypesInState(CONFIGURE_ACTIVE, config_state_map),
       disabled_types);
-  syncer::ModelTypeSet inactive_types =
-      GetDataTypesInState(CONFIGURE_INACTIVE, config_state_map);
   types_to_download.RemoveAll(syncer::ProxyTypes());
   if (!types_to_download.Empty())
     types_to_download.Put(syncer::NIGORI);
 
   // TODO(sync): crbug.com/137550.
   // It's dangerous to configure types that have progress markers.  Types with
   // progress markers can trigger a MIGRATION_DONE response.  We are not
   // prepared to handle a migration during a configure, so we must ensure that
   // all our types_to_download actually contain no data before we sync them.
   //
   // One common way to end up in this situation used to be types which
   // downloaded some or all of their data but have not applied it yet.  We avoid
   // problems with those types by purging the data of any such partially synced
   // types soon after we load the directory.
   //
   // Another possible scenario is that we have newly supported or newly enabled
   // data types being downloaded here but the nigori type, which is always
   // included in any GetUpdates request, requires migration.  The server has
   // code to detect this scenario based on the configure reason, the fact that
   // the nigori type is the only requested type which requires migration, and
   // that the requested types list includes at least one non-nigori type.  It
   // will not send a MIGRATION_DONE response in that case.  We still need to be
   // careful to not send progress markers for non-nigori types, though.  If a
   // non-nigori type in the request requires migration, a MIGRATION_DONE
   // response will be sent.
 
   syncer::ModelSafeRoutingInfo routing_info;
   registrar_->GetModelSafeRoutingInfo(&routing_info);
 
+  syncer::ModelTypeSet current_types = registrar_->GetLastConfiguredTypes();
+  syncer::ModelTypeSet types_to_purge =
+      syncer::Difference(previous_types, current_types);
+  syncer::ModelTypeSet inactive_types =
+      GetDataTypesInState(CONFIGURE_INACTIVE, config_state_map);
+  types_to_purge.RemoveAll(inactive_types);
+  DCHECK(types_to_purge.HasAll(fatal_types));
+  DCHECK(types_to_purge.HasAll(crypto_types));
+
   SDVLOG(1) << "Types "
             << syncer::ModelTypeSetToString(types_to_download)
             << " added; calling DoConfigureSyncer";
   // Divide up the types into their corresponding actions (each is mutually
   // exclusive):
   // - 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,
                          crypto_types,
                          inactive_types,
                          routing_info,
                          ready_task,
                          retry_callback);
 }
 
 void SyncBackendHost::EnableEncryptEverything() {
   sync_thread_.message_loop()->PostTask(FROM_HERE,
@@ skipping 63 matching lines @@
 }
 
 void SyncBackendHost::InitCore(const DoInitializeOptions& options) {
   sync_thread_.message_loop()->PostTask(FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoInitialize, core_.get(), options));
 }
 
 void SyncBackendHost::RequestConfigureSyncer(
     syncer::ConfigureReason reason,
     syncer::ModelTypeSet to_download,
+    syncer::ModelTypeSet to_purge,
     syncer::ModelTypeSet to_journal,
     syncer::ModelTypeSet to_unapply,
     syncer::ModelTypeSet to_ignore,
     const syncer::ModelSafeRoutingInfo& routing_info,
     const base::Callback<void(syncer::ModelTypeSet,
                               syncer::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;
-  config_types.to_ignore = to_ignore;
   sync_thread_.message_loop()->PostTask(FROM_HERE,
        base::Bind(&SyncBackendHost::Core::DoConfigureSyncer,
                   core_.get(),
                   reason,
                   config_types,
                   routing_info,
                   ready_task,
                   retry_callback));
 }
 
@@ skipping 137 matching lines @@
 void SyncBackendHost::Core::DoDownloadControlTypes(
     syncer::ConfigureReason reason) {
   syncer::ModelTypeSet new_control_types = registrar_->ConfigureDataTypes(
       syncer::ControlTypes(), syncer::ModelTypeSet());
   syncer::ModelSafeRoutingInfo routing_info;
   registrar_->GetModelSafeRoutingInfo(&routing_info);
   SDVLOG(1) << "Control Types "
             << syncer::ModelTypeSetToString(new_control_types)
             << " added; calling ConfigureSyncer";
 
+  syncer::ModelTypeSet types_to_purge =
+      syncer::Difference(syncer::ModelTypeSet::All(),
+                         GetRoutingInfoTypes(routing_info));
+
   sync_manager_->ConfigureSyncer(
       reason,
       new_control_types,
-      syncer::ModelTypeSet(),
+      types_to_purge,
       syncer::ModelTypeSet(),
       syncer::ModelTypeSet(),
       routing_info,
       base::Bind(&SyncBackendHost::Core::DoInitialProcessControlTypes,
                  this),
       base::Bind(&SyncBackendHost::Core::OnControlTypesDownloadRetry,
                  this));
 }
 
 void SyncBackendHost::Core::DoRefreshTypes(syncer::ModelTypeSet types) {
@@ skipping 399 matching lines @@
     syncer::ConfigureReason reason,
     const DoConfigureSyncerTypes& config_types,
     const syncer::ModelSafeRoutingInfo routing_info,
     const base::Callback<void(syncer::ModelTypeSet,
                               syncer::ModelTypeSet)>& ready_task,
     const base::Closure& retry_callback) {
   DCHECK_EQ(base::MessageLoop::current(), sync_loop_);
   sync_manager_->ConfigureSyncer(
       reason,
       config_types.to_download,
+      config_types.to_purge,
       config_types.to_journal,
       config_types.to_unapply,
-      config_types.to_ignore,
       routing_info,
       base::Bind(&SyncBackendHost::Core::DoFinishConfigureDataTypes,
                  this,
                  config_types.to_download,
                  ready_task),
       base::Bind(&SyncBackendHost::Core::DoRetryConfiguration,
                  this,
                  retry_callback));
 }
 
@@ skipping 253 matching lines @@
   DVLOG(1) << "Connection status changed: "
            << syncer::ConnectionStatusToString(status);
   frontend_->OnConnectionStatusChange(status);
 }
 
 #undef SDVLOG
 
 #undef SLOG
 
 }  // namespace browser_sync