[Sync] Add RequestCleanupDisabledTypes() method to SyncManager

chrome/browser/sync/engine/sync_scheduler.h

 // 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.
 //
 // A class to schedule syncer tasks intelligently.
 #ifndef CHROME_BROWSER_SYNC_ENGINE_SYNC_SCHEDULER_H_
 #define CHROME_BROWSER_SYNC_ENGINE_SYNC_SCHEDULER_H_
 #pragma once
 
 #include <string>
@@ skipping 75 matching lines @@
   void ScheduleNudge(const base::TimeDelta& delay, NudgeSource source,
                      const syncable::ModelTypeBitSet& types,
                      const tracked_objects::Location& nudge_location);
   void ScheduleNudgeWithPayloads(
       const base::TimeDelta& delay, NudgeSource source,
       const syncable::ModelTypePayloadMap& types_with_payloads,
       const tracked_objects::Location& nudge_location);
   void ScheduleConfig(const syncable::ModelTypeBitSet& types,
       sync_api::ConfigureReason reason);
   void ScheduleClearUserData();
+  void ScheduleCleanupDisabledTypes();
 
   // Change status of notifications in the SyncSessionContext.
   void set_notifications_enabled(bool notifications_enabled);
 
   // DDOS avoidance function.  Calculates how long we should wait before trying
   // again after a failed sync attempt, where the last delay was |base_delay|.
   // TODO(tim): Look at URLRequestThrottlerEntryInterface.
   static base::TimeDelta GetRecommendedDelay(const base::TimeDelta& base_delay);
 
   // SyncSession::Delegate implementation.
@@ skipping 171 matching lines @@
   // Decide on whether to CONTINUE, SAVE or DROP the job when we are in
   // backoff mode.
   JobProcessDecision DecideWhileInWaitInterval(const SyncSessionJob& job);
 
   // Saves the job for future execution. Note: It drops all the poll jobs.
   void SaveJob(const SyncSessionJob& job);
 
   // Coalesces the current job with the pending nudge.
   void InitOrCoalescePendingJob(const SyncSessionJob& job);
 
+  // Cleans up disabled types separately from a sync cycle.
+  void CleanupDisabledTypes();

[tim (not reviewing), 2011/07/28 01:42:23]

So, I get why this is here, but it confuses me to have two separate ways to do
this. Since the canonical way the syncer works is via its internal state
machine, maybe we should be thinking about this that way.  E.g. I just realized
a better way to do what I tried to do before (pulling SyncerEndCommand out of
the cycle) would have been to simply add a condition in case APPLY_UPDATES:,
around the assignment to next_state, to consider the end_state.  If end_state ==
APPLY_UPDATES then next_state = SYNCER_END.

I think that solves all the world's problems?

[akalin, 2011/07/28 02:45:51]

Done.  Let's see if that works.

+
   // 'Impl' here refers to real implementation of public functions, running on
   // |thread_|.
   void StartImpl(Mode mode, ModeChangeCallback* callback);
   void ScheduleNudgeImpl(
       const base::TimeDelta& delay,
       sync_pb::GetUpdatesCallerInfo::GetUpdatesSource source,
       const syncable::ModelTypePayloadMap& types_with_payloads,
       bool is_canary_job, const tracked_objects::Location& nudge_location);
   void ScheduleConfigImpl(const ModelSafeRoutingInfo& routing_info,
       const std::vector<ModelSafeWorker*>& workers,
@@ skipping 82 matching lines @@
   scoped_ptr<Syncer> syncer_;
 
   scoped_ptr<sessions::SyncSessionContext> session_context_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncScheduler);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_ENGINE_SYNC_SCHEDULER_H_