[Sync] Add RequestCleanupDisabledTypes() method to SyncManager

chrome/browser/sync/glue/sync_backend_host.cc

 // Copyright (c) 2011 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 <algorithm>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 323 matching lines @@
     // profile node.
     DCHECK(false);
 
     // just set it as not migrated.
     SetAutofillMigrationState(syncable::NOT_MIGRATED);
     return;
   }
 }
 
 SyncBackendHost::PendingConfigureDataTypesState::
-PendingConfigureDataTypesState() : deleted_type(false),
-    reason(sync_api::CONFIGURE_REASON_UNKNOWN) {}
+PendingConfigureDataTypesState()
+  : reason(sync_api::CONFIGURE_REASON_UNKNOWN) {}
 
 SyncBackendHost::PendingConfigureDataTypesState::
 ~PendingConfigureDataTypesState() {}
 
 SyncBackendHost::PendingConfigureDataTypesState*
     SyncBackendHost::MakePendingConfigModeState(
         const DataTypeController::TypeMap& data_type_controllers,
         const syncable::ModelTypeSet& types,
         CancelableTask* ready_task,
         ModelSafeRoutingInfo* routing_info,
         sync_api::ConfigureReason reason,
         bool nigori_enabled) {
   PendingConfigureDataTypesState* state = new PendingConfigureDataTypesState();
   for (DataTypeController::TypeMap::const_iterator it =
            data_type_controllers.begin();
        it != data_type_controllers.end(); ++it) {
     syncable::ModelType type = it->first;
     // If a type is not specified, remove it from the routing_info.
     if (types.count(type) == 0) {
-      state->deleted_type = true;
       routing_info->erase(type);
     } else {
       // Add a newly specified data type as GROUP_PASSIVE into the
       // routing_info, if it does not already exist.
       if (routing_info->count(type) == 0) {
         (*routing_info)[type] = GROUP_PASSIVE;
         state->added_types.set(type);
       }
     }
   }
 
   // We must handle NIGORI separately as it has no DataTypeController.
   if (types.count(syncable::NIGORI) == 0) {
     if (nigori_enabled) { // Nigori is currently enabled.
-      state->deleted_type = true;
       routing_info->erase(syncable::NIGORI);
       // IsNigoriEnabled is now false.
     }
   } else { // Nigori needs to be enabled.
     if (!nigori_enabled) {
       // Currently it is disabled. So enable it.
       (*routing_info)[syncable::NIGORI] = GROUP_PASSIVE;
       state->added_types.set(syncable::NIGORI);
     }
   }
@@ skipping 52 matching lines @@
   // manner (see issue 56416).
   //
   // In the case of additions, on the next sync cycle, the syncer should
   // notice that the routing info has changed and start the process of
   // downloading updates for newly added data types.  Once this is
   // complete, the configure_state_.ready_task_ is run via an
   // OnInitializationComplete notification.
 
   VLOG(1) << "Syncer in config mode. SBH executing"
           << "FinishConfigureDataTypesOnFrontendLoop";
-  if (pending_config_mode_state_->deleted_type) {
-    sync_thread_.message_loop()->PostTask(FROM_HERE,
-        NewRunnableMethod(core_.get(),
-        &SyncBackendHost::Core::DeferNudgeForCleanup));
-  }
 
   if (pending_config_mode_state_->added_types.none() &&
       !core_->sync_manager()->InitialSyncEndedForAllEnabledTypes()) {
     LOG(WARNING) << "No new types, but initial sync not finished."
                  << "Possible sync db corruption / removal.";
     // TODO(tim): Log / UMA / count this somehow?
     // TODO(tim): If no added types, we could (should?) config only for
     // types that are needed... but this is a rare corruption edge case or
     // implies the user mucked around with their syncdb, so for now do all.
     pending_config_mode_state_->added_types =
@@ skipping 227 matching lines @@
 void SyncBackendHost::LogUnsyncedItems(int level) const {
   DCHECK(initialized());
   return core_->sync_manager()->LogUnsyncedItems(level);
 }
 
 SyncBackendHost::Core::Core(const std::string& name, SyncBackendHost* backend)
     : name_(name),
       host_(backend),
       sync_manager_observer_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       parent_router_(NULL),
-      processing_passphrase_(false),
-      deferred_nudge_for_cleanup_requested_(false) {
-}
+      processing_passphrase_(false) {}
 
 // Helper to construct a user agent string (ASCII) suitable for use by
 // the syncapi for any HTTP communication. This string is used by the sync
 // backend for classifying client types when calculating statistics.
 std::string MakeUserAgentForSyncApi() {
   std::string user_agent;
   user_agent = "Chrome ";
 #if defined(OS_WIN)
   user_agent += "WIN ";
 #elif defined(OS_LINUX)
@@ skipping 58 matching lines @@
 }
 
 void SyncBackendHost::Core::DoUpdateEnabledTypes() {
   DCHECK(MessageLoop::current() == host_->sync_thread_.message_loop());
   sync_manager_->UpdateEnabledTypes();
 }
 
 void SyncBackendHost::Core::DoStartSyncing() {
   DCHECK(MessageLoop::current() == host_->sync_thread_.message_loop());
   sync_manager_->StartSyncingNormally();
-  if (deferred_nudge_for_cleanup_requested_)
-    sync_manager_->RequestNudge(FROM_HERE);
-  deferred_nudge_for_cleanup_requested_ = false;
 }
 
 void SyncBackendHost::Core::DoSetPassphrase(const std::string& passphrase,
                                             bool is_explicit) {
   DCHECK(MessageLoop::current() == host_->sync_thread_.message_loop());
   sync_manager_->SetPassphrase(passphrase, is_explicit);
 }
 
 bool SyncBackendHost::Core::processing_passphrase() const {
   DCHECK(MessageLoop::current() == host_->frontend_loop_);
@@ skipping 419 matching lines @@
   sync_manager_->RemoveObserver(&sync_manager_observer_);
 }
 
 void SyncBackendHost::Core::DoProcessMessage(
     const std::string& name, const JsArgList& args,
     const JsEventHandler* sender) {
   DCHECK_EQ(MessageLoop::current(), host_->sync_thread_.message_loop());
   sync_manager_->GetJsBackend()->ProcessMessage(name, args, sender);
 }
 
-void SyncBackendHost::Core::DeferNudgeForCleanup() {
-  DCHECK_EQ(MessageLoop::current(), host_->sync_thread_.message_loop());
-  deferred_nudge_for_cleanup_requested_ = true;
-}
-
 }  // namespace browser_sync