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

components/sync/core_impl/sync_manager_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/core_impl/sync_manager_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
@@ skipping 22 matching lines @@
 #include "components/sync/core/read_node.h"
 #include "components/sync/core/read_transaction.h"
 #include "components/sync/core/user_share.h"
 #include "components/sync/core/write_node.h"
 #include "components/sync/core/write_transaction.h"
 #include "components/sync/core_impl/change_reorder_buffer.h"
 #include "components/sync/core_impl/model_type_connector_proxy.h"
 #include "components/sync/core_impl/syncapi_internal.h"
 #include "components/sync/core_impl/syncapi_server_connection_manager.h"
 #include "components/sync/engine/polling_constants.h"
+#include "components/sync/engine_impl/cycle/directory_type_debug_info_emitter.h"
 #include "components/sync/engine_impl/sync_scheduler.h"
 #include "components/sync/engine_impl/syncer_types.h"
 #include "components/sync/protocol/proto_value_conversions.h"
 #include "components/sync/protocol/sync.pb.h"
-#include "components/sync/sessions_impl/directory_type_debug_info_emitter.h"
 #include "components/sync/syncable/directory.h"
 #include "components/sync/syncable/entry.h"
 #include "components/sync/syncable/in_memory_directory_backing_store.h"
 #include "components/sync/syncable/on_disk_directory_backing_store.h"
 
 using base::TimeDelta;
 using sync_pb::GetUpdatesCallerInfo;
 
 class GURL;
 
 namespace syncer {
 
-using sessions::SyncSessionContext;
 using syncable::ImmutableWriteTransactionInfo;
 using syncable::SPECIFICS;
 using syncable::UNIQUE_POSITION;
 
 namespace {
 
 GetUpdatesCallerInfo::GetUpdatesSource GetSourceFromReason(
     ConfigureReason reason) {
   switch (reason) {
     case CONFIGURE_REASON_RECONFIGURATION:
@@ skipping 227 matching lines @@
 
   DVLOG(1) << "Setting sync client ID: " << sync_id;
   allstatus_.SetSyncId(sync_id);
   DVLOG(1) << "Setting invalidator client ID: " << args->invalidator_client_id;
   allstatus_.SetInvalidatorClientId(args->invalidator_client_id);
 
   model_type_registry_.reset(
       new ModelTypeRegistry(args->workers, directory(), this));
   sync_encryption_handler_->AddObserver(model_type_registry_.get());
 
-  // Build a SyncSessionContext and store the worker in it.
-  DVLOG(1) << "Sync is bringing up SyncSessionContext.";
+  // Build a SyncCycleContext and store the worker in it.
+  DVLOG(1) << "Sync is bringing up SyncCycleContext.";
   std::vector<SyncEngineEventListener*> listeners;
   listeners.push_back(&allstatus_);
   listeners.push_back(this);
-  session_context_ = args->internal_components_factory->BuildContext(
+  cycle_context_ = args->internal_components_factory->BuildContext(
       connection_manager_.get(), directory(), args->extensions_activity,
       listeners, &debug_info_event_listener_, model_type_registry_.get(),
       args->invalidator_client_id);
   scheduler_ = args->internal_components_factory->BuildScheduler(
-      name_, session_context_.get(), args->cancelation_signal);
+      name_, cycle_context_.get(), args->cancelation_signal);
 
   scheduler_->Start(SyncScheduler::CONFIGURATION_MODE, base::Time());
 
   initialized_ = true;
 
   net::NetworkChangeNotifier::AddIPAddressObserver(this);
   net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
   observing_network_connectivity_changes_ = true;
 
   UpdateCredentials(args->credentials);
@@ skipping 64 matching lines @@
 
 void SyncManagerImpl::StartSyncingNormally(
     const ModelSafeRoutingInfo& routing_info,
     base::Time last_poll_time) {
   // Start the sync scheduler.
   // TODO(sync): We always want the newest set of routes when we switch back
   // to normal mode. Figure out how to enforce set_routing_info is always
   // appropriately set and that it's only modified when switching to normal
   // mode.
   DCHECK(thread_checker_.CalledOnValidThread());
-  session_context_->SetRoutingInfo(routing_info);
+  cycle_context_->SetRoutingInfo(routing_info);
   scheduler_->Start(SyncScheduler::NORMAL_MODE, last_poll_time);
 }
 
 syncable::Directory* SyncManagerImpl::directory() {
   return share_.directory.get();
 }
 
 const SyncScheduler* SyncManagerImpl::scheduler() const {
   return scheduler_.get();
 }
@@ skipping 60 matching lines @@
   DCHECK(to_purge.HasAll(to_unapply));
   return directory()->PurgeEntriesWithTypeIn(to_purge, to_journal, to_unapply);
 }
 
 void SyncManagerImpl::UpdateCredentials(const SyncCredentials& credentials) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(initialized_);
   DCHECK(!credentials.account_id.empty());
   DCHECK(!credentials.sync_token.empty());
   DCHECK(!credentials.scope_set.empty());
-  session_context_->set_account_name(credentials.email);
+  cycle_context_->set_account_name(credentials.email);
 
   observing_network_connectivity_changes_ = true;
   if (!connection_manager_->SetAuthToken(credentials.sync_token))
     return;  // Auth token is known to be invalid, so exit early.
 
   scheduler_->OnCredentialsUpdated();
 
   // TODO(zea): pass the credential age to the debug info event listener.
 }
 
 void SyncManagerImpl::AddObserver(SyncManager::Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observers_.AddObserver(observer);
 }
 
 void SyncManagerImpl::RemoveObserver(SyncManager::Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observers_.RemoveObserver(observer);
 }
 
 void SyncManagerImpl::ShutdownOnSyncThread(ShutdownReason reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Prevent any in-flight method calls from running.  Also
   // invalidates |weak_handle_this_| and |change_observer_|.
   weak_ptr_factory_.InvalidateWeakPtrs();
   js_mutation_event_observer_.InvalidateWeakPtrs();
 
   scheduler_.reset();
-  session_context_.reset();
+  cycle_context_.reset();
 
   if (model_type_registry_)
     sync_encryption_handler_->RemoveObserver(model_type_registry_.get());
 
   model_type_registry_.reset();
 
   if (sync_encryption_handler_) {
     sync_encryption_handler_->RemoveObserver(&debug_info_event_listener_);
     sync_encryption_handler_->RemoveObserver(this);
   }
@@ skipping 413 matching lines @@
         favicon_sync_node.GetExperimentsSpecifics()
             .favicon_sync()
             .favicon_sync_limit();
     found_experiment = true;
   }
 
   ReadNode pre_commit_update_avoidance_node(&trans);
   if (pre_commit_update_avoidance_node.InitByClientTagLookup(
           syncer::EXPERIMENTS, syncer::kPreCommitUpdateAvoidanceTag) ==
       BaseNode::INIT_OK) {
-    session_context_->set_server_enabled_pre_commit_update_avoidance(
+    cycle_context_->set_server_enabled_pre_commit_update_avoidance(
         pre_commit_update_avoidance_node.GetExperimentsSpecifics()
             .pre_commit_update_avoidance()
             .enabled());
     // We don't bother setting found_experiment.  The frontend doesn't need to
     // know about this.
   }
 
   ReadNode gcm_invalidations_node(&trans);
   if (gcm_invalidations_node.InitByClientTagLookup(
           syncer::EXPERIMENTS, syncer::kGCMInvalidationsTag) ==
@@ skipping 45 matching lines @@
 void SyncManagerImpl::ClearServerData(const ClearServerDataCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   scheduler_->Start(SyncScheduler::CLEAR_SERVER_DATA_MODE, base::Time());
   ClearParams params(callback);
   scheduler_->ScheduleClearServerData(params);
 }
 
 void SyncManagerImpl::OnCookieJarChanged(bool account_mismatch,
                                          bool empty_jar) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  session_context_->set_cookie_jar_mismatch(account_mismatch);
-  session_context_->set_cookie_jar_empty(empty_jar);
+  cycle_context_->set_cookie_jar_mismatch(account_mismatch);
+  cycle_context_->set_cookie_jar_empty(empty_jar);
 }
 
 }  // namespace syncer