[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/bind.h"
 #include "base/command_line.h"
@@ skipping 370 matching lines @@
   // 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));
+        &SyncBackendHost::Core::DeferCleanup));
   }
 
   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.
@@ skipping 38 matching lines @@
      NewRunnableMethod(core_.get(),
                        &SyncBackendHost::Core::DoEncryptDataTypes,
                        encrypted_types));
 }
 
 syncable::ModelTypeSet SyncBackendHost::GetEncryptedDataTypes() const {
   DCHECK_GT(initialization_state_, NOT_INITIALIZED);
   return core_->sync_manager()->GetEncryptedDataTypes();
 }
 
-void SyncBackendHost::RequestNudge(const tracked_objects::Location& location) {
-  sync_thread_.message_loop()->PostTask(FROM_HERE,
-      NewRunnableMethod(core_.get(), &SyncBackendHost::Core::DoRequestNudge,
-                        location));
-}
-
 void SyncBackendHost::ActivateDataType(
     DataTypeController* data_type_controller,
     ChangeProcessor* change_processor) {
   base::AutoLock lock(registrar_lock_);
 
   // Ensure that the given data type is in the PASSIVE group.
   browser_sync::ModelSafeRoutingInfo::iterator i =
       registrar_.routing_info.find(data_type_controller->type());
   DCHECK(i != registrar_.routing_info.end());
   DCHECK((*i).second == GROUP_PASSIVE);
@@ skipping 165 matching lines @@
   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) {
+      deferred_cleanup_requested_(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 ";
@@ skipping 59 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;
+  if (deferred_cleanup_requested_)
+    sync_manager_->RequestCleanupDisabledTypes();
+  deferred_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 339 matching lines @@
 
   parent_router_->RouteJsMessageReply(name, args, target);
 }
 
 void SyncBackendHost::Core::StartSavingChanges() {
   save_changes_timer_.Start(
       base::TimeDelta::FromSeconds(kSaveChangesIntervalSeconds),
       this, &Core::SaveChanges);
 }
 
-void SyncBackendHost::Core::DoRequestNudge(
-    const tracked_objects::Location& nudge_location) {
-  sync_manager_->RequestNudge(nudge_location);
-}
-
 void SyncBackendHost::Core::DoRequestClearServerData() {
   sync_manager_->RequestClearServerData();
 }
 
 void SyncBackendHost::Core::SaveChanges() {
   sync_manager_->SaveChanges();
 }
 
 void SyncBackendHost::Core::DeleteSyncDataFolder() {
   if (file_util::DirectoryExists(host_->sync_data_folder_path())) {
@@ skipping 59 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() {
+void SyncBackendHost::Core::DeferCleanup() {
   DCHECK_EQ(MessageLoop::current(), host_->sync_thread_.message_loop());
-  deferred_nudge_for_cleanup_requested_ = true;
+  deferred_cleanup_requested_ = true;
 }
 
 }  // namespace browser_sync