[Sync] Move sessions/ to engine/cycle/ and rename things to match.

components/sync/engine_impl/sync_scheduler_impl.h

 // Copyright 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.
 
 #ifndef COMPONENTS_SYNC_ENGINE_IMPL_SYNC_SCHEDULER_IMPL_H_
 #define COMPONENTS_SYNC_ENGINE_IMPL_SYNC_SCHEDULER_IMPL_H_
 
 #include <map>
 #include <memory>
 #include <string>
 
 #include "base/callback.h"
 #include "base/cancelable_callback.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "components/sync/base/weak_handle.h"
 #include "components/sync/engine/polling_constants.h"
+#include "components/sync/engine_impl/cycle/nudge_tracker.h"
+#include "components/sync/engine_impl/cycle/sync_cycle.h"
+#include "components/sync/engine_impl/cycle/sync_cycle_context.h"
 #include "components/sync/engine_impl/net/server_connection_manager.h"
 #include "components/sync/engine_impl/nudge_source.h"
 #include "components/sync/engine_impl/sync_scheduler.h"
 #include "components/sync/engine_impl/syncer.h"
-#include "components/sync/sessions_impl/nudge_tracker.h"
-#include "components/sync/sessions_impl/sync_session.h"
-#include "components/sync/sessions_impl/sync_session_context.h"
 
 namespace syncer {
 
 class BackoffDelayProvider;
-
-namespace sessions {
 struct ModelNeutralState;
-}
 
 class SyncSchedulerImpl : public SyncScheduler, public base::NonThreadSafe {
  public:
   // |name| is a display string to identify the syncer thread.  Takes
   // |ownership of |syncer| and |delay_provider|.
   SyncSchedulerImpl(const std::string& name,
                     BackoffDelayProvider* delay_provider,
-                    sessions::SyncSessionContext* context,
+                    SyncCycleContext* context,
                     Syncer* syncer);
 
   // Calls Stop().
   ~SyncSchedulerImpl() override;
 
   void Start(Mode mode, base::Time last_poll_time) override;
   void ScheduleConfiguration(const ConfigurationParams& params) override;
   void ScheduleClearServerData(const ClearParams& params) override;
   void Stop() override;
   void ScheduleLocalNudge(
       ModelTypeSet types,
       const tracked_objects::Location& nudge_location) override;
   void ScheduleLocalRefreshRequest(
       ModelTypeSet types,
       const tracked_objects::Location& nudge_location) override;
   void ScheduleInvalidationNudge(
       syncer::ModelType type,
       std::unique_ptr<InvalidationInterface> invalidation,
       const tracked_objects::Location& nudge_location) override;
   void ScheduleInitialSyncNudge(syncer::ModelType model_type) override;
   void SetNotificationsEnabled(bool notifications_enabled) override;
 
   void OnCredentialsUpdated() override;
   void OnConnectionStatusChange() override;
 
-  // SyncSession::Delegate implementation.
+  // SyncCycle::Delegate implementation.
   void OnThrottled(const base::TimeDelta& throttle_duration) override;
   void OnTypesThrottled(ModelTypeSet types,
                         const base::TimeDelta& throttle_duration) override;
   bool IsCurrentlyThrottled() override;
   void OnReceivedShortPollIntervalUpdate(
       const base::TimeDelta& new_interval) override;
   void OnReceivedLongPollIntervalUpdate(
       const base::TimeDelta& new_interval) override;
   void OnReceivedCustomNudgeDelays(
       const std::map<ModelType, base::TimeDelta>& nudge_delays) override;
@@ skipping 55 matching lines @@
 
     Mode mode;
     base::TimeDelta length;
   };
 
   static const char* GetModeString(Mode mode);
 
   void SetDefaultNudgeDelay(base::TimeDelta delay_ms);
 
   // Invoke the syncer to perform a nudge job.
-  void DoNudgeSyncSessionJob(JobPriority priority);
+  void DoNudgeSyncCycleJob(JobPriority priority);
 
   // Invoke the syncer to perform a configuration job.
-  void DoConfigurationSyncSessionJob(JobPriority priority);
+  void DoConfigurationSyncCycleJob(JobPriority priority);
 
-  void DoClearServerDataSyncSessionJob(JobPriority priority);
+  void DoClearServerDataSyncCycleJob(JobPriority priority);
 
-  // Helper function for Do{Nudge,Configuration,Poll}SyncSessionJob.
+  // Helper function for Do{Nudge,Configuration,Poll}SyncCycleJob.
   void HandleSuccess();
 
-  // Helper function for Do{Nudge,Configuration,Poll}SyncSessionJob.
-  void HandleFailure(const sessions::ModelNeutralState& model_neutral_state);
+  // Helper function for Do{Nudge,Configuration,Poll}SyncCycleJob.
+  void HandleFailure(const ModelNeutralState& model_neutral_state);
 
   // Invoke the Syncer to perform a poll job.
-  void DoPollSyncSessionJob();
+  void DoPollSyncCycleJob();
 
   // Helper function to calculate poll interval.
   base::TimeDelta GetPollInterval();
 
   // Adjusts the poll timer to account for new poll interval, and possibly
   // resets the poll interval, depedning on the flag's value.
   void AdjustPolling(PollAdjustType type);
 
   // Helper to restart waiting with |wait_interval_|'s timer.
   void RestartWaiting();
@@ skipping 14 matching lines @@
   // Helper to signal listeners about changed retry time.
   void NotifyRetryTime(base::Time retry_time);
 
   // Helper to signal listeners about changed throttled types.
   void NotifyThrottledTypesChanged(ModelTypeSet types);
 
   // Looks for pending work and, if it finds any, run this work at "canary"
   // priority.
   void TryCanaryJob();
 
-  // At the moment TrySyncSessionJob just posts call to TrySyncSessionJobImpl on
+  // At the moment TrySyncCycleJob just posts call to TrySyncCycleJobImpl on
   // current thread. In the future it will request access token here.
-  void TrySyncSessionJob();
-  void TrySyncSessionJobImpl();
+  void TrySyncCycleJob();
+  void TrySyncCycleJobImpl();
 
   // Transitions out of the THROTTLED WaitInterval then calls TryCanaryJob().
   void Unthrottle();
 
   // Called when a per-type throttling interval expires.
   void TypeUnthrottle(base::TimeTicks unthrottle_time);
 
   // Runs a normal nudge job when the scheduled timer expires.
   void PerformDelayedNudge();
 
   // Attempts to exit EXPONENTIAL_BACKOFF by calling TryCanaryJob().
   void ExponentialBackoffRetry();
 
   // Called when the root cause of the current connection error is fixed.
   void OnServerConnectionErrorFixed();
 
-  // Creates a session for a poll and performs the sync.
+  // Creates a cycle for a poll and performs the sync.
   void PollTimerCallback();
 
-  // Creates a session for a retry and performs the sync.
+  // Creates a cycle for a retry and performs the sync.
   void RetryTimerCallback();
 
   // Returns the set of types that are enabled and not currently throttled.
   ModelTypeSet GetEnabledAndUnthrottledTypes();
 
-  // Called as we are started to broadcast an initial session snapshot
+  // Called as we are started to broadcast an initial cycle snapshot
   // containing data like initial_sync_ended.  Important when the client starts
   // up and does not need to perform an initial sync.
   void SendInitialSnapshot();
 
   // This is used for histogramming and analysis of ScheduleNudge* APIs.
   // SyncScheduler is the ultimate choke-point for all such invocations (with
   // and without InvalidationState variants, all NudgeSources, etc) and as such
   // is the most flexible place to do this bookkeeping.
   void UpdateNudgeTimeRecords(ModelTypeSet types);
 
@@ skipping 33 matching lines @@
   // Storage for variables related to an in-progress configure request.  Note
   // that (mode_ != CONFIGURATION_MODE) \implies !pending_configure_params_.
   std::unique_ptr<ConfigurationParams> pending_configure_params_;
 
   std::unique_ptr<ClearParams> pending_clear_params_;
 
   // If we have a nudge pending to run soon, it will be listed here.
   base::TimeTicks scheduled_nudge_time_;
 
   // Keeps track of work that the syncer needs to handle.
-  sessions::NudgeTracker nudge_tracker_;
+  NudgeTracker nudge_tracker_;
 
   // Invoked to run through the sync cycle.
   std::unique_ptr<Syncer> syncer_;
 
-  sessions::SyncSessionContext* session_context_;
+  SyncCycleContext* cycle_context_;
 
   // A map tracking LOCAL NudgeSource invocations of ScheduleNudge* APIs,
   // organized by datatype. Each datatype that was part of the types requested
   // in the call will have its TimeTicks value updated.
   typedef std::map<ModelType, base::TimeTicks> ModelTypeTimeMap;
   ModelTypeTimeMap last_local_nudges_by_model_type_;
 
   // Used as an "anti-reentrancy defensive assertion".
   // While true, it is illegal for any new scheduling activity to take place.
   // Ensures that higher layers don't break this law in response to events that
   // take place during a sync cycle. We call this out because such violations
   // could result in tight sync loops hitting sync servers.
   bool no_scheduling_allowed_;
 
   // TryJob might get called for multiple reasons. It should only call
-  // DoPollSyncSessionJob after some time since the last attempt.
+  // DoPollSyncCycleJob after some time since the last attempt.
   // last_poll_reset_ keeps track of when was last attempt.
   base::TimeTicks last_poll_reset_;
 
-  // next_sync_session_job_priority_ defines which priority will be used next
-  // time TrySyncSessionJobImpl is called. CANARY_PRIORITY allows syncer to run
+  // next_sync_cycle_job_priority_ defines which priority will be used next
+  // time TrySyncCycleJobImpl is called. CANARY_PRIORITY allows syncer to run
   // even if scheduler is in exponential backoff. This is needed for events that
   // have chance of resolving previous error (e.g. network connection change
   // after NETWORK_UNAVAILABLE error).
-  // It is reset back to NORMAL_PRIORITY on every call to TrySyncSessionJobImpl.
-  JobPriority next_sync_session_job_priority_;
+  // It is reset back to NORMAL_PRIORITY on every call to TrySyncCycleJobImpl.
+  JobPriority next_sync_cycle_job_priority_;
 
   // One-shot timer for scheduling GU retry according to delay set by server.
   base::OneShotTimer retry_timer_;
 
   base::WeakPtrFactory<SyncSchedulerImpl> weak_ptr_factory_;
 
   // A second factory specially for weak_handle_this_, to allow the handle
   // to be const and alleviate threading concerns.
   base::WeakPtrFactory<SyncSchedulerImpl> weak_ptr_factory_for_weak_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncSchedulerImpl);
 };
 
 }  // namespace syncer
 
 #endif  // COMPONENTS_SYNC_ENGINE_IMPL_SYNC_SCHEDULER_IMPL_H_