Revert 146262 - Revert "Revert 142517 - [Sync] Refactor sync configuration logic."

sync/engine/sync_scheduler.h

 // 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.
 //
 // A class to schedule syncer tasks intelligently.
 #ifndef SYNC_ENGINE_SYNC_SCHEDULER_H_
 #define SYNC_ENGINE_SYNC_SCHEDULER_H_
 
 #include <string>
 
@@ skipping 18 matching lines @@
 class MessageLoop;
 
 namespace tracked_objects {
 class Location;
 }  // namespace tracked_objects
 
 namespace syncer {
 
 struct ServerConnectionEvent;
 
-struct ConfigurationParams {
-  enum KeystoreKeyStatus {
-    KEYSTORE_KEY_UNNECESSARY,
-    KEYSTORE_KEY_NEEDED
-  };
-  ConfigurationParams();
-  ConfigurationParams(
-      const sync_pb::GetUpdatesCallerInfo::GetUpdatesSource& source,
-      const syncer::ModelTypeSet& types_to_download,
-      const syncer::ModelSafeRoutingInfo& routing_info,
-      KeystoreKeyStatus keystore_key_status,
-      const base::Closure& ready_task);
-  ~ConfigurationParams();
-
-  // Source for the configuration.
-  sync_pb::GetUpdatesCallerInfo::GetUpdatesSource source;
-  // The types that should be downloaded.
-  syncer::ModelTypeSet types_to_download;
-  // The new routing info (superset of types to be downloaded).
-  ModelSafeRoutingInfo routing_info;
-  // Whether we need to perform a GetKey command.
-  KeystoreKeyStatus keystore_key_status;
-  // Callback to invoke on configuration completion.
-  base::Closure ready_task;
-};
-
 class SyncScheduler : public sessions::SyncSession::Delegate {
  public:
   enum Mode {
     // In this mode, the thread only performs configuration tasks.  This is
     // designed to make the case where we want to download updates for a
     // specific type only, and not continue syncing until we are moved into
     // normal mode.
     CONFIGURATION_MODE,
     // Resumes polling and allows nudges, drops configuration tasks.  Runs
     // through entire sync cycle.
     NORMAL_MODE,
   };
 
   // All methods of SyncScheduler must be called on the same thread
   // (except for RequestEarlyExit()).
 
   // |name| is a display string to identify the syncer thread.  Takes
   // |ownership of |syncer|.
   SyncScheduler(const std::string& name,
                 sessions::SyncSessionContext* context, Syncer* syncer);
 
   // Calls Stop().
   virtual ~SyncScheduler();
 
   // Start the scheduler with the given mode.  If the scheduler is
   // already started, switch to the given mode, although some
-  // scheduled tasks from the old mode may still run.
-  virtual void Start(Mode mode);
-
-  // Schedules the configuration task specified by |params|. Returns true if
-  // the configuration task executed immediately, false if it had to be
-  // scheduled for a later attempt. |params.ready_task| is invoked whenever the
-  // configuration task executes.
-  // Note: must already be in CONFIGURATION mode.
-  virtual bool ScheduleConfiguration(const ConfigurationParams& params);
+  // scheduled tasks from the old mode may still run.  If non-NULL,
+  // |callback| will be invoked when the mode has been changed to
+  // |mode|.  Takes ownership of |callback|.
+  void Start(Mode mode, const base::Closure& callback);
 
   // Request that any running syncer task stop as soon as possible and
   // cancel all scheduled tasks. This function can be called from any thread,
   // and should in fact be called from a thread that isn't the sync loop to
   // allow preempting ongoing sync cycles.
   // Invokes |callback| from the sync loop once syncer is idle and all tasks
   // are cancelled.
   void RequestStop(const base::Closure& callback);
 
   // The meat and potatoes. Both of these methods will post a delayed task
   // to attempt the actual nudge (see ScheduleNudgeImpl).
   void ScheduleNudgeAsync(const base::TimeDelta& delay, NudgeSource source,
-                          syncer::ModelTypeSet types,
-                          const tracked_objects::Location& nudge_location);
+                     syncer::ModelTypeSet types,
+                     const tracked_objects::Location& nudge_location);
   void ScheduleNudgeWithPayloadsAsync(
       const base::TimeDelta& delay, NudgeSource source,
       const syncer::ModelTypePayloadMap& types_with_payloads,
       const tracked_objects::Location& nudge_location);
 
+  // Schedule a configuration cycle. May execute immediately or at a later time
+  // (depending on backoff/throttle state).
+  // Note: The source argument of this function must come from the subset of
+  // GetUpdatesCallerInfo values related to configurations.
+  void ScheduleConfiguration(
+      syncer::ModelTypeSet types,
+      sync_pb::GetUpdatesCallerInfo::GetUpdatesSource source);
+
   void CleanupDisabledTypes();
 
   // Change status of notifications in the SyncSessionContext.
   void set_notifications_enabled(bool notifications_enabled);
 
   base::TimeDelta sessions_commit_delay() const;
 
   // 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.
@@ skipping 44 matching lines @@
       // during initial sync or reconfiguration.  We don't run all steps of
       // the sync cycle for these (e.g. CleanupDisabledTypes is skipped).
       CONFIGURATION,
       // The user disabled some types and we have to clean up the data
       // for those.
       CLEANUP_DISABLED_TYPES,
     };
     SyncSessionJob();
     SyncSessionJob(SyncSessionJobPurpose purpose, base::TimeTicks start,
         linked_ptr<sessions::SyncSession> session, bool is_canary_job,
-        const ConfigurationParams& config_params,
         const tracked_objects::Location& nudge_location);
     ~SyncSessionJob();
     static const char* GetPurposeString(SyncSessionJobPurpose purpose);
 
     SyncSessionJobPurpose purpose;
     base::TimeTicks scheduled_start;
     linked_ptr<sessions::SyncSession> session;
     bool is_canary_job;
-    ConfigurationParams config_params;
 
     // This is the location the job came from.  Used for debugging.
     // In case of multiple nudges getting coalesced this stores the
     // first location that came in.
     tracked_objects::Location from_here;
   };
   friend class SyncSchedulerTest;
   friend class SyncSchedulerWhiteboxTest;
   friend class SyncerTest;
 
@@ skipping 219 matching lines @@
   scoped_ptr<Syncer> syncer_;
 
   sessions::SyncSessionContext *session_context_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncScheduler);
 };
 
 }  // namespace syncer
 
 #endif  // SYNC_ENGINE_SYNC_SCHEDULER_H_