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

components/sync/engine_impl/sync_scheduler_impl.cc

 // 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.
 
 #include "components/sync/engine_impl/sync_scheduler_impl.h"
 
 #include <algorithm>
 #include <cstring>
 #include <utility>
 
@@ skipping 10 matching lines @@
 #include "components/sync/engine_impl/backoff_delay_provider.h"
 #include "components/sync/engine_impl/syncer.h"
 #include "components/sync/protocol/proto_enum_conversions.h"
 #include "components/sync/protocol/sync.pb.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace syncer {
 
-using sessions::SyncSession;
-using sessions::SyncSessionSnapshot;
 using sync_pb::GetUpdatesCallerInfo;
 
 namespace {
 
 bool IsConfigRelatedUpdateSourceValue(
     GetUpdatesCallerInfo::GetUpdatesSource source) {
   switch (source) {
     case GetUpdatesCallerInfo::RECONFIGURATION:
     case GetUpdatesCallerInfo::MIGRATION:
     case GetUpdatesCallerInfo::NEW_CLIENT:
@@ skipping 120 matching lines @@
 
 #define SLOG(severity) LOG(severity) << name_ << ": "
 
 #define SDVLOG(verbose_level) DVLOG(verbose_level) << name_ << ": "
 
 #define SDVLOG_LOC(from_here, verbose_level) \
   DVLOG_LOC(from_here, verbose_level) << name_ << ": "
 
 SyncSchedulerImpl::SyncSchedulerImpl(const std::string& name,
                                      BackoffDelayProvider* delay_provider,
-                                     sessions::SyncSessionContext* context,
+                                     SyncCycleContext* context,
                                      Syncer* syncer)
     : name_(name),
       started_(false),
       syncer_short_poll_interval_seconds_(
           TimeDelta::FromSeconds(kDefaultShortPollIntervalSeconds)),
       syncer_long_poll_interval_seconds_(
           TimeDelta::FromSeconds(kDefaultLongPollIntervalSeconds)),
       mode_(CONFIGURATION_MODE),
       delay_provider_(delay_provider),
       syncer_(syncer),
-      session_context_(context),
-      next_sync_session_job_priority_(NORMAL_PRIORITY),
+      cycle_context_(context),
+      next_sync_cycle_job_priority_(NORMAL_PRIORITY),
       weak_ptr_factory_(this),
       weak_ptr_factory_for_weak_handle_(this) {
   weak_handle_this_ =
       MakeWeakHandle(weak_ptr_factory_for_weak_handle_.GetWeakPtr());
 }
 
 SyncSchedulerImpl::~SyncSchedulerImpl() {
   DCHECK(CalledOnValidThread());
   Stop();
 }
 
 void SyncSchedulerImpl::OnCredentialsUpdated() {
   DCHECK(CalledOnValidThread());
 
   if (HttpResponse::SYNC_AUTH_ERROR ==
-      session_context_->connection_manager()->server_status()) {
+      cycle_context_->connection_manager()->server_status()) {
     OnServerConnectionErrorFixed();
   }
 }
 
 void SyncSchedulerImpl::OnConnectionStatusChange() {
   if (HttpResponse::CONNECTION_UNAVAILABLE ==
-      session_context_->connection_manager()->server_status()) {
+      cycle_context_->connection_manager()->server_status()) {
     // Optimistically assume that the connection is fixed and try
     // connecting.
     OnServerConnectionErrorFixed();
   }
 }
 
 void SyncSchedulerImpl::OnServerConnectionErrorFixed() {
   // There could be a pending nudge or configuration job in several cases:
   //
   // 1. We're in exponential backoff.
@@ skipping 41 matching lines @@
 
   if (old_mode != mode_ && mode_ == NORMAL_MODE) {
     // We just got back to normal mode.  Let's try to run the work that was
     // queued up while we were configuring.
 
     AdjustPolling(UPDATE_INTERVAL);  // Will kick start poll timer if needed.
 
     // Update our current time before checking IsRetryRequired().
     nudge_tracker_.SetSyncCycleStartTime(base::TimeTicks::Now());
     if (nudge_tracker_.IsSyncRequired() && CanRunNudgeJobNow(NORMAL_PRIORITY)) {
-      TrySyncSessionJob();
+      TrySyncCycleJob();
     }
   }
 }
 
 ModelTypeSet SyncSchedulerImpl::GetEnabledAndUnthrottledTypes() {
-  ModelTypeSet enabled_types = session_context_->GetEnabledTypes();
+  ModelTypeSet enabled_types = cycle_context_->GetEnabledTypes();
   ModelTypeSet enabled_protocol_types =
       Intersection(ProtocolTypes(), enabled_types);
   ModelTypeSet throttled_types = nudge_tracker_.GetThrottledTypes();
   return Difference(enabled_protocol_types, throttled_types);
 }
 
 void SyncSchedulerImpl::SendInitialSnapshot() {
   DCHECK(CalledOnValidThread());
-  std::unique_ptr<SyncSession> dummy(
-      SyncSession::Build(session_context_, this));
+  std::unique_ptr<SyncCycle> dummy(SyncCycle::Build(cycle_context_, this));
   SyncCycleEvent event(SyncCycleEvent::STATUS_CHANGED);
   event.snapshot = dummy->TakeSnapshot();
-  FOR_EACH_OBSERVER(SyncEngineEventListener, *session_context_->listeners(),
+  FOR_EACH_OBSERVER(SyncEngineEventListener, *cycle_context_->listeners(),
                     OnSyncCycleEvent(event));
 }
 
 namespace {
 
 // Helper to extract the routing info corresponding to types in
 // |types_to_download| from |current_routes|.
 void BuildModelSafeParams(ModelTypeSet types_to_download,
                           const ModelSafeRoutingInfo& current_routes,
                           ModelSafeRoutingInfo* result_routes) {
@@ skipping 18 matching lines @@
   CHECK(started_) << "Scheduler must be running to configure.";
   SDVLOG(2) << "Reconfiguring syncer.";
 
   // Only one configuration is allowed at a time. Verify we're not waiting
   // for a pending configure job.
   DCHECK(!pending_configure_params_);
 
   ModelSafeRoutingInfo restricted_routes;
   BuildModelSafeParams(params.types_to_download, params.routing_info,
                        &restricted_routes);
-  session_context_->SetRoutingInfo(restricted_routes);
+  cycle_context_->SetRoutingInfo(restricted_routes);
 
   // Only reconfigure if we have types to download.
   if (!params.types_to_download.Empty()) {
     pending_configure_params_.reset(new ConfigurationParams(params));
-    TrySyncSessionJob();
+    TrySyncCycleJob();
   } else {
     SDVLOG(2) << "No change in routing info, calling ready task directly.";
     params.ready_task.Run();
   }
 }
 
 void SyncSchedulerImpl::ScheduleClearServerData(const ClearParams& params) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(CLEAR_SERVER_DATA_MODE, mode_);
   DCHECK(!pending_configure_params_);
   DCHECK(!params.report_success_task.is_null());
   CHECK(started_) << "Scheduler must be running to clear.";
   pending_clear_params_.reset(new ClearParams(params));
-  TrySyncSessionJob();
+  TrySyncCycleJob();
 }
 
 bool SyncSchedulerImpl::CanRunJobNow(JobPriority priority) {
   DCHECK(CalledOnValidThread());
   if (IsCurrentlyThrottled()) {
     SDVLOG(1) << "Unable to run a job because we're throttled.";
     return false;
   }
 
   if (IsBackingOff() && priority != CANARY_PRIORITY) {
     SDVLOG(1) << "Unable to run a job because we're backing off.";
     return false;
   }
 
-  if (session_context_->connection_manager()->HasInvalidAuthToken()) {
+  if (cycle_context_->connection_manager()->HasInvalidAuthToken()) {
     SDVLOG(1) << "Unable to run a job because we have no valid auth token.";
     return false;
   }
 
   return true;
 }
 
 bool SyncSchedulerImpl::CanRunNudgeJobNow(JobPriority priority) {
   DCHECK(CalledOnValidThread());
 
   if (!CanRunJobNow(priority)) {
     SDVLOG(1) << "Unable to run a nudge job right now";
     return false;
   }
 
-  const ModelTypeSet enabled_types = session_context_->GetEnabledTypes();
+  const ModelTypeSet enabled_types = cycle_context_->GetEnabledTypes();
   if (nudge_tracker_.GetThrottledTypes().HasAll(enabled_types)) {
     SDVLOG(1) << "Not running a nudge because we're fully type throttled.";
     return false;
   }
 
   if (mode_ != NORMAL_MODE) {
     SDVLOG(1) << "Not running nudge because we're not in normal mode.";
     return false;
   }
 
@@ skipping 94 matching lines @@
     ENUM_CASE(NORMAL_MODE);
   }
   return "";
 }
 
 void SyncSchedulerImpl::SetDefaultNudgeDelay(base::TimeDelta delay_ms) {
   DCHECK(CalledOnValidThread());
   nudge_tracker_.SetDefaultNudgeDelay(delay_ms);
 }
 
-void SyncSchedulerImpl::DoNudgeSyncSessionJob(JobPriority priority) {
+void SyncSchedulerImpl::DoNudgeSyncCycleJob(JobPriority priority) {
   DCHECK(CalledOnValidThread());
   DCHECK(CanRunNudgeJobNow(priority));
 
   DVLOG(2) << "Will run normal mode sync cycle with types "
-           << ModelTypeSetToString(session_context_->GetEnabledTypes());
-  std::unique_ptr<SyncSession> session(
-      SyncSession::Build(session_context_, this));
+           << ModelTypeSetToString(cycle_context_->GetEnabledTypes());
+  std::unique_ptr<SyncCycle> cycle(SyncCycle::Build(cycle_context_, this));
   bool success = syncer_->NormalSyncShare(GetEnabledAndUnthrottledTypes(),
-                                          &nudge_tracker_, session.get());
+                                          &nudge_tracker_, cycle.get());
 
   if (success) {
     // That cycle took care of any outstanding work we had.
     SDVLOG(2) << "Nudge succeeded.";
     nudge_tracker_.RecordSuccessfulSyncCycle();
     scheduled_nudge_time_ = base::TimeTicks();
     HandleSuccess();
 
     // If this was a canary, we may need to restart the poll timer (the poll
     // timer may have fired while the scheduler was in an error state, ignoring
     // the poll).
     if (!poll_timer_.IsRunning()) {
       SDVLOG(1) << "Canary succeeded, restarting polling.";
       AdjustPolling(UPDATE_INTERVAL);
     }
   } else {
-    HandleFailure(session->status_controller().model_neutral_state());
+    HandleFailure(cycle->status_controller().model_neutral_state());
   }
 }
 
-void SyncSchedulerImpl::DoConfigurationSyncSessionJob(JobPriority priority) {
+void SyncSchedulerImpl::DoConfigurationSyncCycleJob(JobPriority priority) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(mode_, CONFIGURATION_MODE);
   DCHECK(pending_configure_params_ != NULL);
 
   if (!CanRunJobNow(priority)) {
     SDVLOG(2) << "Unable to run configure job right now.";
     RunAndReset(&pending_configure_params_->retry_task);
     return;
   }
 
   SDVLOG(2) << "Will run configure SyncShare with types "
-            << ModelTypeSetToString(session_context_->GetEnabledTypes());
-  std::unique_ptr<SyncSession> session(
-      SyncSession::Build(session_context_, this));
+            << ModelTypeSetToString(cycle_context_->GetEnabledTypes());
+  std::unique_ptr<SyncCycle> cycle(SyncCycle::Build(cycle_context_, this));
   bool success = syncer_->ConfigureSyncShare(
       pending_configure_params_->types_to_download,
-      pending_configure_params_->source, session.get());
+      pending_configure_params_->source, cycle.get());
 
   if (success) {
     SDVLOG(2) << "Configure succeeded.";
     pending_configure_params_->ready_task.Run();
     pending_configure_params_.reset();
     HandleSuccess();
   } else {
-    HandleFailure(session->status_controller().model_neutral_state());
+    HandleFailure(cycle->status_controller().model_neutral_state());
     // Sync cycle might receive response from server that causes scheduler to
     // stop and draws pending_configure_params_ invalid.
     if (started_)
       RunAndReset(&pending_configure_params_->retry_task);
   }
 }
 
-void SyncSchedulerImpl::DoClearServerDataSyncSessionJob(JobPriority priority) {
+void SyncSchedulerImpl::DoClearServerDataSyncCycleJob(JobPriority priority) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(mode_, CLEAR_SERVER_DATA_MODE);
 
   if (!CanRunJobNow(priority)) {
     SDVLOG(2) << "Unable to run clear server data job right now.";
     RunAndReset(&pending_configure_params_->retry_task);
     return;
   }
 
-  std::unique_ptr<SyncSession> session(
-      SyncSession::Build(session_context_, this));
-  const bool success = syncer_->PostClearServerData(session.get());
+  std::unique_ptr<SyncCycle> cycle(SyncCycle::Build(cycle_context_, this));
+  const bool success = syncer_->PostClearServerData(cycle.get());
   if (!success) {
-    HandleFailure(session->status_controller().model_neutral_state());
+    HandleFailure(cycle->status_controller().model_neutral_state());
     return;
   }
 
   SDVLOG(2) << "Clear succeeded.";
   pending_clear_params_->report_success_task.Run();
   pending_clear_params_.reset();
   HandleSuccess();
 }
 
 void SyncSchedulerImpl::HandleSuccess() {
   // If we're here, then we successfully reached the server.  End all backoff.
   wait_interval_.reset();
   NotifyRetryTime(base::Time());
 }
 
 void SyncSchedulerImpl::HandleFailure(
-    const sessions::ModelNeutralState& model_neutral_state) {
+    const ModelNeutralState& model_neutral_state) {
   if (IsCurrentlyThrottled()) {
     SDVLOG(2) << "Was throttled during previous sync cycle.";
   } else if (!IsBackingOff()) {
     // Setup our backoff if this is our first such failure.
     TimeDelta length = delay_provider_->GetDelay(
         delay_provider_->GetInitialDelay(model_neutral_state));
     wait_interval_.reset(
         new WaitInterval(WaitInterval::EXPONENTIAL_BACKOFF, length));
     SDVLOG(2) << "Sync cycle failed.  Will back off for "
               << wait_interval_->length.InMilliseconds() << "ms.";
   } else {
     // Increase our backoff interval and schedule another retry.
     TimeDelta length = delay_provider_->GetDelay(wait_interval_->length);
     wait_interval_.reset(
         new WaitInterval(WaitInterval::EXPONENTIAL_BACKOFF, length));
     SDVLOG(2) << "Sync cycle failed.  Will back off for "
               << wait_interval_->length.InMilliseconds() << "ms.";
   }
   RestartWaiting();
 }
 
-void SyncSchedulerImpl::DoPollSyncSessionJob() {
+void SyncSchedulerImpl::DoPollSyncCycleJob() {
   SDVLOG(2) << "Polling with types "
             << ModelTypeSetToString(GetEnabledAndUnthrottledTypes());
-  std::unique_ptr<SyncSession> session(
-      SyncSession::Build(session_context_, this));
+  std::unique_ptr<SyncCycle> cycle(SyncCycle::Build(cycle_context_, this));
   bool success =
-      syncer_->PollSyncShare(GetEnabledAndUnthrottledTypes(), session.get());
+      syncer_->PollSyncShare(GetEnabledAndUnthrottledTypes(), cycle.get());
 
   // Only restart the timer if the poll succeeded. Otherwise rely on normal
   // failure handling to retry with backoff.
   if (success) {
     AdjustPolling(FORCE_RESET);
     HandleSuccess();
   } else {
-    HandleFailure(session->status_controller().model_neutral_state());
+    HandleFailure(cycle->status_controller().model_neutral_state());
   }
 }
 
 void SyncSchedulerImpl::UpdateNudgeTimeRecords(ModelTypeSet types) {
   DCHECK(CalledOnValidThread());
   base::TimeTicks now = TimeTicks::Now();
   // Update timing information for how often datatypes are triggering nudges.
   for (ModelTypeSet::Iterator iter = types.First(); iter.Good(); iter.Inc()) {
     base::TimeTicks previous = last_local_nudges_by_model_type_[iter.Get()];
     last_local_nudges_by_model_type_[iter.Get()] = now;
     if (previous.is_null())
       continue;
 
 #define PER_DATA_TYPE_MACRO(type_str) \
   SYNC_FREQ_HISTOGRAM("Sync.Freq" type_str, now - previous);
     SYNC_DATA_TYPE_HISTOGRAM(iter.Get());
 #undef PER_DATA_TYPE_MACRO
   }
 }
 
 TimeDelta SyncSchedulerImpl::GetPollInterval() {
-  return (!session_context_->notifications_enabled() ||
-          !session_context_->ShouldFetchUpdatesBeforeCommit())
+  return (!cycle_context_->notifications_enabled() ||
+          !cycle_context_->ShouldFetchUpdatesBeforeCommit())
              ? syncer_short_poll_interval_seconds_
              : syncer_long_poll_interval_seconds_;
 }
 
 void SyncSchedulerImpl::AdjustPolling(PollAdjustType type) {
   DCHECK(CalledOnValidThread());
   if (!started_)
     return;
 
   TimeDelta poll_interval = GetPollInterval();
@@ skipping 61 matching lines @@
   wait_interval_.reset();
   NotifyRetryTime(base::Time());
   poll_timer_.Stop();
   pending_wakeup_timer_.Stop();
   pending_configure_params_.reset();
   pending_clear_params_.reset();
   if (started_)
     started_ = false;
 }
 
-// This is the only place where we invoke DoSyncSessionJob with canary
+// This is the only place where we invoke DoSyncCycleJob with canary
 // privileges.  Everyone else should use NORMAL_PRIORITY.
 void SyncSchedulerImpl::TryCanaryJob() {
-  next_sync_session_job_priority_ = CANARY_PRIORITY;
+  next_sync_cycle_job_priority_ = CANARY_PRIORITY;
   SDVLOG(2) << "Attempting canary job";
-  TrySyncSessionJob();
+  TrySyncCycleJob();
 }
 
-void SyncSchedulerImpl::TrySyncSessionJob() {
-  // Post call to TrySyncSessionJobImpl on current thread. Later request for
+void SyncSchedulerImpl::TrySyncCycleJob() {
+  // Post call to TrySyncCycleJobImpl on current thread. Later request for
   // access token will be here.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&SyncSchedulerImpl::TrySyncSessionJobImpl,
+      FROM_HERE, base::Bind(&SyncSchedulerImpl::TrySyncCycleJobImpl,
                             weak_ptr_factory_.GetWeakPtr()));
 }
 
-void SyncSchedulerImpl::TrySyncSessionJobImpl() {
-  JobPriority priority = next_sync_session_job_priority_;
-  next_sync_session_job_priority_ = NORMAL_PRIORITY;
+void SyncSchedulerImpl::TrySyncCycleJobImpl() {
+  JobPriority priority = next_sync_cycle_job_priority_;
+  next_sync_cycle_job_priority_ = NORMAL_PRIORITY;
 
   nudge_tracker_.SetSyncCycleStartTime(base::TimeTicks::Now());
 
   DCHECK(CalledOnValidThread());
   if (mode_ == CONFIGURATION_MODE) {
     if (pending_configure_params_) {
       SDVLOG(2) << "Found pending configure job";
-      DoConfigurationSyncSessionJob(priority);
+      DoConfigurationSyncCycleJob(priority);
     }
   } else if (mode_ == CLEAR_SERVER_DATA_MODE) {
     if (pending_clear_params_) {
-      DoClearServerDataSyncSessionJob(priority);
+      DoClearServerDataSyncCycleJob(priority);
     }
   } else if (CanRunNudgeJobNow(priority)) {
     if (nudge_tracker_.IsSyncRequired()) {
       SDVLOG(2) << "Found pending nudge job";
-      DoNudgeSyncSessionJob(priority);
+      DoNudgeSyncCycleJob(priority);
     } else if (((base::TimeTicks::Now() - last_poll_reset_) >=
                 GetPollInterval())) {
       SDVLOG(2) << "Found pending poll";
-      DoPollSyncSessionJob();
+      DoPollSyncCycleJob();
     }
   } else {
     // We must be in an error state. Transitioning out of each of these
     // error states should trigger a canary job.
     DCHECK(IsCurrentlyThrottled() || IsBackingOff() ||
-           session_context_->connection_manager()->HasInvalidAuthToken());
+           cycle_context_->connection_manager()->HasInvalidAuthToken());
   }
 
   if (IsBackingOff() && !pending_wakeup_timer_.IsRunning()) {
     // If we succeeded, our wait interval would have been cleared.  If it hasn't
     // been cleared, then we should increase our backoff interval and schedule
     // another retry.
     TimeDelta length = delay_provider_->GetDelay(wait_interval_->length);
     wait_interval_.reset(
         new WaitInterval(WaitInterval::EXPONENTIAL_BACKOFF, length));
     SDVLOG(2) << "Sync cycle failed.  Will back off for "
               << wait_interval_->length.InMilliseconds() << "ms.";
     RestartWaiting();
   }
 }
 
 void SyncSchedulerImpl::PollTimerCallback() {
   DCHECK(CalledOnValidThread());
   CHECK(!syncer_->IsSyncing());
 
-  TrySyncSessionJob();
+  TrySyncCycleJob();
 }
 
 void SyncSchedulerImpl::RetryTimerCallback() {
-  TrySyncSessionJob();
+  TrySyncCycleJob();
 }
 
 void SyncSchedulerImpl::Unthrottle() {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(WaitInterval::THROTTLED, wait_interval_->mode);
 
   // We're no longer throttled, so clear the wait interval.
   wait_interval_.reset();
   NotifyRetryTime(base::Time());
   NotifyThrottledTypesChanged(nudge_tracker_.GetThrottledTypes());
@@ skipping 16 matching lines @@
     base::TimeDelta time_until_next_unthrottle =
         nudge_tracker_.GetTimeUntilNextUnthrottle(now);
     type_unthrottle_timer_.Start(FROM_HERE, time_until_next_unthrottle,
                                  base::Bind(&SyncSchedulerImpl::TypeUnthrottle,
                                             weak_ptr_factory_.GetWeakPtr(),
                                             now + time_until_next_unthrottle));
   }
 
   // Maybe this is a good time to run a nudge job.  Let's try it.
   if (nudge_tracker_.IsSyncRequired() && CanRunNudgeJobNow(NORMAL_PRIORITY))
-    TrySyncSessionJob();
+    TrySyncCycleJob();
 }
 
 void SyncSchedulerImpl::PerformDelayedNudge() {
   // Circumstances may have changed since we scheduled this delayed nudge.
   // We must check to see if it's OK to run the job before we do so.
   if (CanRunNudgeJobNow(NORMAL_PRIORITY))
-    TrySyncSessionJob();
+    TrySyncCycleJob();
 
   // We're not responsible for setting up any retries here.  The functions that
   // first put us into a state that prevents successful sync cycles (eg. global
   // throttling, type throttling, network errors, transient errors) will also
   // setup the appropriate retry logic (eg. retry after timeout, exponential
   // backoff, retry when the network changes).
 }
 
 void SyncSchedulerImpl::ExponentialBackoffRetry() {
   TryCanaryJob();
 }
 
 void SyncSchedulerImpl::NotifyRetryTime(base::Time retry_time) {
-  FOR_EACH_OBSERVER(SyncEngineEventListener, *session_context_->listeners(),
+  FOR_EACH_OBSERVER(SyncEngineEventListener, *cycle_context_->listeners(),
                     OnRetryTimeChanged(retry_time));
 }
 
 void SyncSchedulerImpl::NotifyThrottledTypesChanged(ModelTypeSet types) {
-  FOR_EACH_OBSERVER(SyncEngineEventListener, *session_context_->listeners(),
+  FOR_EACH_OBSERVER(SyncEngineEventListener, *cycle_context_->listeners(),
                     OnThrottledTypesChanged(types));
 }
 
 bool SyncSchedulerImpl::IsBackingOff() const {
   DCHECK(CalledOnValidThread());
   return wait_interval_.get() &&
          wait_interval_->mode == WaitInterval::EXPONENTIAL_BACKOFF;
 }
 
 void SyncSchedulerImpl::OnThrottled(const base::TimeDelta& throttle_duration) {
@@ skipping 65 matching lines @@
 
 void SyncSchedulerImpl::OnSyncProtocolError(
     const SyncProtocolError& sync_protocol_error) {
   DCHECK(CalledOnValidThread());
   if (ShouldRequestEarlyExit(sync_protocol_error)) {
     SDVLOG(2) << "Sync Scheduler requesting early exit.";
     Stop();
   }
   if (IsActionableError(sync_protocol_error)) {
     SDVLOG(2) << "OnActionableError";
-    FOR_EACH_OBSERVER(SyncEngineEventListener, *session_context_->listeners(),
+    FOR_EACH_OBSERVER(SyncEngineEventListener, *cycle_context_->listeners(),
                       OnActionableError(sync_protocol_error));
   }
 }
 
 void SyncSchedulerImpl::OnReceivedGuRetryDelay(const base::TimeDelta& delay) {
   nudge_tracker_.SetNextRetryTime(TimeTicks::Now() + delay);
   retry_timer_.Start(FROM_HERE, delay, this,
                      &SyncSchedulerImpl::RetryTimerCallback);
 }
 
 void SyncSchedulerImpl::OnReceivedMigrationRequest(ModelTypeSet types) {
-  FOR_EACH_OBSERVER(SyncEngineEventListener, *session_context_->listeners(),
+  FOR_EACH_OBSERVER(SyncEngineEventListener, *cycle_context_->listeners(),
                     OnMigrationRequested(types));
 }
 
 void SyncSchedulerImpl::SetNotificationsEnabled(bool notifications_enabled) {
   DCHECK(CalledOnValidThread());
-  session_context_->set_notifications_enabled(notifications_enabled);
+  cycle_context_->set_notifications_enabled(notifications_enabled);
   if (notifications_enabled)
     nudge_tracker_.OnInvalidationsEnabled();
   else
     nudge_tracker_.OnInvalidationsDisabled();
 }
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // namespace syncer