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

components/sync/engine_impl/syncer_unittest.cc

 // 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.
 //
 // Syncer unit tests. Unfortunately a lot of these tests
 // are outdated and need to be reworked and updated.
 
 #include "components/sync/engine_impl/syncer.h"
 
 #include <stddef.h>
@@ skipping 17 matching lines @@
 #include "base/strings/string_number_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "components/sync/base/cancelation_signal.h"
 #include "components/sync/base/cryptographer.h"
 #include "components/sync/base/extensions_activity.h"
 #include "components/sync/base/fake_encryptor.h"
 #include "components/sync/base/model_type.h"
 #include "components/sync/base/time.h"
+#include "components/sync/engine/cycle/commit_counters.h"
+#include "components/sync/engine/cycle/status_counters.h"
+#include "components/sync/engine/cycle/update_counters.h"
 #include "components/sync/engine/model_safe_worker.h"
 #include "components/sync/engine_impl/backoff_delay_provider.h"
+#include "components/sync/engine_impl/cycle/mock_debug_info_getter.h"
+#include "components/sync/engine_impl/cycle/sync_cycle_context.h"
 #include "components/sync/engine_impl/get_commit_ids.h"
 #include "components/sync/engine_impl/net/server_connection_manager.h"
 #include "components/sync/engine_impl/sync_scheduler_impl.h"
 #include "components/sync/engine_impl/syncer_proto_util.h"
 #include "components/sync/protocol/bookmark_specifics.pb.h"
 #include "components/sync/protocol/nigori_specifics.pb.h"
 #include "components/sync/protocol/preference_specifics.pb.h"
 #include "components/sync/protocol/sync.pb.h"
-#include "components/sync/sessions/commit_counters.h"
-#include "components/sync/sessions/status_counters.h"
-#include "components/sync/sessions/update_counters.h"
-#include "components/sync/sessions_impl/sync_session_context.h"
 #include "components/sync/syncable/mutable_entry.h"
 #include "components/sync/syncable/nigori_util.h"
 #include "components/sync/syncable/syncable_delete_journal.h"
 #include "components/sync/syncable/syncable_read_transaction.h"
 #include "components/sync/syncable/syncable_util.h"
 #include "components/sync/syncable/syncable_write_transaction.h"
 #include "components/sync/test/engine/fake_model_worker.h"
 #include "components/sync/test/engine/mock_connection_manager.h"
 #include "components/sync/test/engine/mock_nudge_handler.h"
 #include "components/sync/test/engine/test_directory_setter_upper.h"
 #include "components/sync/test/engine/test_id_factory.h"
 #include "components/sync/test/engine/test_syncable_utils.h"
 #include "components/sync/test/fake_sync_encryption_handler.h"
-#include "components/sync/test/sessions/mock_debug_info_getter.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
 
 using std::count;
 using std::map;
 using std::multimap;
 using std::set;
 using std::string;
@@ skipping 13 matching lines @@
 using syncable::WriteTransaction;
 
 using syncable::CREATE;
 using syncable::GET_BY_HANDLE;
 using syncable::GET_BY_ID;
 using syncable::GET_BY_CLIENT_TAG;
 using syncable::GET_BY_SERVER_TAG;
 using syncable::GET_TYPE_ROOT;
 using syncable::UNITTEST;
 
-using sessions::MockDebugInfoGetter;
-using sessions::StatusController;
-using sessions::SyncSessionContext;
-using sessions::SyncSession;
-
 namespace {
 
 // A helper to hold on to the counters emitted by the sync engine.
 class TypeDebugInfoCache : public TypeDebugInfoObserver {
  public:
   TypeDebugInfoCache();
   ~TypeDebugInfoCache() override;
 
   CommitCounters GetLatestCommitCounters(ModelType type) const;
   UpdateCounters GetLatestUpdateCounters(ModelType type) const;
@@ skipping 64 matching lines @@
 
 void TypeDebugInfoCache::OnStatusCountersUpdated(
     syncer::ModelType type,
     const StatusCounters& counters) {
   status_counters_map_[type] = counters;
 }
 
 }  // namespace
 
 class SyncerTest : public testing::Test,
-                   public SyncSession::Delegate,
+                   public SyncCycle::Delegate,
                    public SyncEngineEventListener {
  protected:
   SyncerTest()
       : extensions_activity_(new ExtensionsActivity),
         syncer_(NULL),
         last_client_invalidation_hint_buffer_size_(10) {}
 
-  // SyncSession::Delegate implementation.
+  // SyncCycle::Delegate implementation.
   void OnThrottled(const base::TimeDelta& throttle_duration) override {
     FAIL() << "Should not get silenced.";
   }
   void OnTypesThrottled(ModelTypeSet types,
                         const base::TimeDelta& throttle_duration) override {
     scheduler_->OnTypesThrottled(types, throttle_duration);
   }
   bool IsCurrentlyThrottled() override { return false; }
   void OnReceivedLongPollIntervalUpdate(
       const base::TimeDelta& new_interval) override {
     last_long_poll_interval_received_ = new_interval;
   }
   void OnReceivedShortPollIntervalUpdate(
       const base::TimeDelta& new_interval) override {
     last_short_poll_interval_received_ = new_interval;
   }
   void OnReceivedCustomNudgeDelays(
       const std::map<ModelType, base::TimeDelta>& delay_map) override {
     std::map<ModelType, base::TimeDelta>::const_iterator iter =
         delay_map.find(SESSIONS);
     if (iter != delay_map.end() && iter->second > base::TimeDelta())
-      last_sessions_commit_delay_ = iter->second;
+      last_cycles_commit_delay_ = iter->second;

[skym, 2016/08/19 17:17:43]

I think this is suppose to be session

[maxbogue, 2016/08/19 19:12:01]

Done.

     iter = delay_map.find(BOOKMARKS);
     if (iter != delay_map.end() && iter->second > base::TimeDelta())
       last_bookmarks_commit_delay_ = iter->second;
   }
   void OnReceivedClientInvalidationHintBufferSize(int size) override {
     last_client_invalidation_hint_buffer_size_ = size;
   }
   void OnReceivedGuRetryDelay(const base::TimeDelta& delay) override {}
   void OnReceivedMigrationRequest(ModelTypeSet types) override {}
   void OnProtocolEvent(const ProtocolEvent& event) override {}
@@ skipping 19 matching lines @@
       default:
         FAIL() << "Handling unknown error type in unit tests!!";
     }
   }
 
   void OnActionableError(const SyncProtocolError& error) override {}
   void OnRetryTimeChanged(base::Time retry_time) override {}
   void OnThrottledTypesChanged(ModelTypeSet throttled_types) override {}
   void OnMigrationRequested(ModelTypeSet types) override {}
 
-  void ResetSession() {
-    session_.reset(SyncSession::Build(context_.get(), this));
-  }
+  void ResetSession() { cycle_.reset(SyncCycle::Build(context_.get(), this)); }

[skym, 2016/08/19 17:17:43]

This should be ResetCycle()

[maxbogue, 2016/08/19 19:12:01]

Done.

 
   bool SyncShareNudge() {
     ResetSession();
 
     // Pretend we've seen a local change, to make the nudge_tracker look normal.
     nudge_tracker_.RecordLocalChange(ModelTypeSet(BOOKMARKS));
 
     return syncer_->NormalSyncShare(context_->GetEnabledTypes(),
-                                    &nudge_tracker_, session_.get());
+                                    &nudge_tracker_, cycle_.get());
   }
 
   bool SyncShareConfigure() {
     ResetSession();
     return syncer_->ConfigureSyncShare(
         context_->GetEnabledTypes(),
-        sync_pb::GetUpdatesCallerInfo::RECONFIGURATION, session_.get());
+        sync_pb::GetUpdatesCallerInfo::RECONFIGURATION, cycle_.get());
   }
 
   void SetUp() override {
     dir_maker_.SetUp();
     mock_server_.reset(
         new MockConnectionManager(directory(), &cancelation_signal_));
     debug_info_getter_.reset(new MockDebugInfoGetter);
     EnableDatatype(BOOKMARKS);
     EnableDatatype(EXTENSIONS);
     EnableDatatype(NIGORI);
     EnableDatatype(PREFERENCES);
     EnableDatatype(NIGORI);
     workers_.push_back(
         scoped_refptr<ModelSafeWorker>(new FakeModelWorker(GROUP_PASSIVE)));
     std::vector<SyncEngineEventListener*> listeners;
     listeners.push_back(this);
 
     ModelSafeRoutingInfo routing_info;
     GetModelSafeRoutingInfo(&routing_info);
 
     model_type_registry_.reset(
         new ModelTypeRegistry(workers_, directory(), &mock_nudge_handler_));
     model_type_registry_->RegisterDirectoryTypeDebugInfoObserver(
         &debug_info_cache_);
 
-    context_.reset(new SyncSessionContext(
+    context_.reset(new SyncCycleContext(
         mock_server_.get(), directory(), extensions_activity_.get(), listeners,
         debug_info_getter_.get(), model_type_registry_.get(),
         true,   // enable keystore encryption
         false,  // force enable pre-commit GU avoidance experiment
         "fake_invalidator_client_id"));
     context_->SetRoutingInfo(routing_info);
     syncer_ = new Syncer(&cancelation_signal_);
     scheduler_.reset(new SyncSchedulerImpl(
         "TestSyncScheduler", BackoffDelayProvider::FromDefaults(),
         context_.get(),
@@ skipping 225 matching lines @@
       context_->SetRoutingInfo(routing_info);
     }
 
     mock_server_->ExpectGetUpdatesRequestTypes(enabled_datatypes_);
   }
 
   Cryptographer* GetCryptographer(syncable::BaseTransaction* trans) {
     return directory()->GetCryptographer(trans);
   }
 
-  // Configures SyncSessionContext and NudgeTracker so Syncer won't call
+  // Configures SyncCycleContext and NudgeTracker so Syncer won't call
   // GetUpdates prior to Commit. This method can be used to ensure a Commit is
   // not preceeded by GetUpdates.
   void ConfigureNoGetUpdatesRequired() {
     context_->set_server_enabled_pre_commit_update_avoidance(true);
     nudge_tracker_.OnInvalidationsEnabled();
     nudge_tracker_.RecordSuccessfulSyncCycle();
 
     ASSERT_FALSE(context_->ShouldFetchUpdatesBeforeCommit());
     ASSERT_FALSE(nudge_tracker_.IsGetUpdatesRequired());
   }
@@ skipping 11 matching lines @@
   TestIdFactory ids_;
 
   TestDirectorySetterUpper dir_maker_;
   FakeEncryptor encryptor_;
   scoped_refptr<ExtensionsActivity> extensions_activity_;
   std::unique_ptr<MockConnectionManager> mock_server_;
   CancelationSignal cancelation_signal_;
 
   Syncer* syncer_;
 
-  std::unique_ptr<SyncSession> session_;
+  std::unique_ptr<SyncCycle> cycle_;
   TypeDebugInfoCache debug_info_cache_;
   MockNudgeHandler mock_nudge_handler_;
   std::unique_ptr<ModelTypeRegistry> model_type_registry_;
   std::unique_ptr<SyncSchedulerImpl> scheduler_;
-  std::unique_ptr<SyncSessionContext> context_;
+  std::unique_ptr<SyncCycleContext> context_;
   base::TimeDelta last_short_poll_interval_received_;
   base::TimeDelta last_long_poll_interval_received_;
-  base::TimeDelta last_sessions_commit_delay_;
+  base::TimeDelta last_cycles_commit_delay_;

[skym, 2016/08/19 17:17:43]

Should be session

[maxbogue, 2016/08/19 19:12:01]

Done.

   base::TimeDelta last_bookmarks_commit_delay_;
   int last_client_invalidation_hint_buffer_size_;
   std::vector<scoped_refptr<ModelSafeWorker>> workers_;
 
   ModelTypeSet enabled_datatypes_;
-  sessions::NudgeTracker nudge_tracker_;
+  NudgeTracker nudge_tracker_;
   std::unique_ptr<MockDebugInfoGetter> debug_info_getter_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SyncerTest);
 };
 
 TEST_F(SyncerTest, TestCallGatherUnsyncedEntries) {
   {
     Syncer::UnsyncedMetaHandles handles;
     {
@@ skipping 24 matching lines @@
     A.PutSpecifics(bookmark_data);
     A.PutNonUniqueName("bookmark");
   }
 
   // Now sync without enabling bookmarks.
   mock_server_->ExpectGetUpdatesRequestTypes(
       Difference(context_->GetEnabledTypes(), ModelTypeSet(BOOKMARKS)));
   ResetSession();
   syncer_->NormalSyncShare(
       Difference(context_->GetEnabledTypes(), ModelTypeSet(BOOKMARKS)),
-      &nudge_tracker_, session_.get());
+      &nudge_tracker_, cycle_.get());
 
   {
     // Nothing should have been committed as bookmarks is throttled.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     Entry entryA(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(entryA.good());
     EXPECT_TRUE(entryA.GetIsUnsynced());
   }
 
   // Sync again with bookmarks enabled.
@@ skipping 52 matching lines @@
     A.PutSpecifics(bookmark_data);
     A.PutNonUniqueName("bookmark");
   }
 
   // Now sync without enabling bookmarks.
   mock_server_->ExpectGetUpdatesRequestTypes(
       Difference(context_->GetEnabledTypes(), ModelTypeSet(BOOKMARKS)));
   ResetSession();
   syncer_->NormalSyncShare(
       Difference(context_->GetEnabledTypes(), ModelTypeSet(BOOKMARKS)),
-      &nudge_tracker_, session_.get());
+      &nudge_tracker_, cycle_.get());
 
   {
     // Nothing should have been committed as bookmarks is throttled.
     histogram_tester.ExpectTotalCount("DataUse.Sync.Upload.Count", 0);
     histogram_tester.ExpectTotalCount("DataUse.Sync.Upload.Bytes", 0);
     histogram_tester.ExpectTotalCount("DataUse.Sync.Download.Count", 1);
     histogram_tester.ExpectUniqueSample("DataUse.Sync.Download.Count",
                                         BOOKMARKS, 1);
 
     samples = histogram_tester.GetAllSamples("DataUse.Sync.Download.Bytes");
@@ skipping 157 matching lines @@
     ASSERT_TRUE(C.good());
     C.PutSpecifics(encrypted_bookmark);
     C.PutNonUniqueName(kEncryptedString);
     MutableEntry D(&wtrans, GET_BY_ID, ids_.FromNumber(4));
     ASSERT_TRUE(D.good());
     D.PutSpecifics(encrypted_bookmark);
     D.PutNonUniqueName(kEncryptedString);
   }
   EXPECT_TRUE(SyncShareNudge());
   {
-    const StatusController& status_controller = session_->status_controller();
+    const StatusController& status_controller = cycle_->status_controller();
     // Expect success.
     EXPECT_EQ(SYNCER_OK, status_controller.model_neutral_state().commit_result);
     // None should be unsynced anymore.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     VERIFY_ENTRY(1, false, false, false, 0, 21, 21, ids_, &rtrans);
     VERIFY_ENTRY(2, false, false, false, 0, 11, 11, ids_, &rtrans);
     VERIFY_ENTRY(3, false, false, false, 0, 11, 11, ids_, &rtrans);
     VERIFY_ENTRY(4, false, false, false, 0, 11, 11, ids_, &rtrans);
   }
 }
@@ skipping 1825 matching lines @@
     entry.PutBaseVersion(1);
     entry.PutServerVersion(1);
     entry.PutServerParentId(ids_.FromNumber(9999));  // Bad parent.
     entry.PutIsUnsynced(true);
     entry.PutIsUnappliedUpdate(true);
     entry.PutSpecifics(DefaultBookmarkSpecifics());
     entry.PutServerSpecifics(DefaultBookmarkSpecifics());
     entry.PutIsDel(false);
   }
   EXPECT_TRUE(SyncShareNudge());
-  EXPECT_EQ(1, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(1, cycle_->status_controller().TotalNumConflictingItems());
 }
 
 // Original problem synopsis:
 //   Illegal parent
 // Unexpected error during sync if we:
 //   make a new folder bob
 //   wait for sync
 //   make a new folder fred
 //   move bob into fred
 //   remove bob
@@ skipping 236 matching lines @@
     entry.PutIsUnsynced(true);
     entry.PutIsUnappliedUpdate(true);
     entry.PutSpecifics(DefaultPreferencesSpecifics());
     entry.PutServerSpecifics(DefaultPreferencesSpecifics());
     entry.PutIsDel(false);
   }
 
   EXPECT_TRUE(SyncShareNudge());
   // Since the hierarchy isn't really changed (the type has flat hierarchy)
   // this conflict must be discarded.
-  EXPECT_EQ(0, session_->status_controller().num_local_overwrites());
-  EXPECT_EQ(0, session_->status_controller().num_server_overwrites());
+  EXPECT_EQ(0, cycle_->status_controller().num_local_overwrites());
+  EXPECT_EQ(0, cycle_->status_controller().num_server_overwrites());
 }
 
 TEST_F(SyncerTest, DeletingEntryWithLocalEdits) {
   int64_t newfolder_metahandle;
 
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10, foreign_cache_guid(),
                                    "-1");
   EXPECT_TRUE(SyncShareNudge());
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
@@ skipping 129 matching lines @@
   }
   ASSERT_EQ(items_to_commit, directory()->unsynced_entity_count());
 
   // The second commit should fail.  It will be preceded by one successful
   // GetUpdate and one succesful commit.
   mock_server_->FailNthPostBufferToPathCall(3);
   EXPECT_FALSE(SyncShareNudge());
 
   EXPECT_EQ(1U, mock_server_->commit_messages().size());
   EXPECT_EQ(SYNC_SERVER_ERROR,
-            session_->status_controller().model_neutral_state().commit_result);
+            cycle_->status_controller().model_neutral_state().commit_result);
   EXPECT_EQ(items_to_commit - kDefaultMaxCommitBatchSize,
             directory()->unsynced_entity_count());
 }
 
 // Test that a single conflict response from the server will cause us to exit
 // the commit loop immediately.
 TEST_F(SyncerTest, CommitManyItemsInOneGo_CommitConflict) {
   uint32_t num_batches = 2;
   uint32_t items_to_commit = kDefaultMaxCommitBatchSize * num_batches;
   {
@@ skipping 945 matching lines @@
       GetSpecificsFieldNumberFromModelType(BOOKMARKS));
   bookmark_delay->set_delay_ms(950);
   command->set_client_invalidation_hint_buffer_size(11);
   mock_server_->AddUpdateDirectory(1, 0, "in_root", 1, 1, foreign_cache_guid(),
                                    "-1");
   mock_server_->SetGUClientCommand(command);
   EXPECT_TRUE(SyncShareNudge());
 
   EXPECT_EQ(TimeDelta::FromSeconds(8), last_short_poll_interval_received_);
   EXPECT_EQ(TimeDelta::FromSeconds(800), last_long_poll_interval_received_);
-  EXPECT_EQ(TimeDelta::FromSeconds(3141), last_sessions_commit_delay_);
+  EXPECT_EQ(TimeDelta::FromSeconds(3141), last_cycles_commit_delay_);
   EXPECT_EQ(TimeDelta::FromMilliseconds(950), last_bookmarks_commit_delay_);
   EXPECT_EQ(11, last_client_invalidation_hint_buffer_size_);
 
   command = new ClientCommand();
   command->set_set_sync_poll_interval(180);
   command->set_set_sync_long_poll_interval(190);
   command->set_sessions_commit_delay_seconds(2718);
   bookmark_delay = command->add_custom_nudge_delays();
   bookmark_delay->set_datatype_id(
       GetSpecificsFieldNumberFromModelType(BOOKMARKS));
   bookmark_delay->set_delay_ms(1050);
   command->set_client_invalidation_hint_buffer_size(9);
   mock_server_->AddUpdateDirectory(1, 0, "in_root", 1, 1, foreign_cache_guid(),
                                    "-1");
   mock_server_->SetGUClientCommand(command);
   EXPECT_TRUE(SyncShareNudge());
 
   EXPECT_EQ(TimeDelta::FromSeconds(180), last_short_poll_interval_received_);
   EXPECT_EQ(TimeDelta::FromSeconds(190), last_long_poll_interval_received_);
-  EXPECT_EQ(TimeDelta::FromSeconds(2718), last_sessions_commit_delay_);
+  EXPECT_EQ(TimeDelta::FromSeconds(2718), last_cycles_commit_delay_);
   EXPECT_EQ(TimeDelta::FromMilliseconds(1050), last_bookmarks_commit_delay_);
   EXPECT_EQ(9, last_client_invalidation_hint_buffer_size_);
 }
 
 TEST_F(SyncerTest, TestClientCommandDuringCommit) {
   using sync_pb::ClientCommand;
 
   ClientCommand* command = new ClientCommand();
   command->set_set_sync_poll_interval(8);
   command->set_set_sync_long_poll_interval(800);
   command->set_sessions_commit_delay_seconds(3141);
   sync_pb::CustomNudgeDelay* bookmark_delay =
       command->add_custom_nudge_delays();
   bookmark_delay->set_datatype_id(
       GetSpecificsFieldNumberFromModelType(BOOKMARKS));
   bookmark_delay->set_delay_ms(950);
   command->set_client_invalidation_hint_buffer_size(11);
   CreateUnsyncedDirectory("X", "id_X");
   mock_server_->SetCommitClientCommand(command);
   EXPECT_TRUE(SyncShareNudge());
 
   EXPECT_EQ(TimeDelta::FromSeconds(8), last_short_poll_interval_received_);
   EXPECT_EQ(TimeDelta::FromSeconds(800), last_long_poll_interval_received_);
-  EXPECT_EQ(TimeDelta::FromSeconds(3141), last_sessions_commit_delay_);
+  EXPECT_EQ(TimeDelta::FromSeconds(3141), last_cycles_commit_delay_);
   EXPECT_EQ(TimeDelta::FromMilliseconds(950), last_bookmarks_commit_delay_);
   EXPECT_EQ(11, last_client_invalidation_hint_buffer_size_);
 
   command = new ClientCommand();
   command->set_set_sync_poll_interval(180);
   command->set_set_sync_long_poll_interval(190);
   command->set_sessions_commit_delay_seconds(2718);
   bookmark_delay = command->add_custom_nudge_delays();
   bookmark_delay->set_datatype_id(
       GetSpecificsFieldNumberFromModelType(BOOKMARKS));
   bookmark_delay->set_delay_ms(1050);
   command->set_client_invalidation_hint_buffer_size(9);
   CreateUnsyncedDirectory("Y", "id_Y");
   mock_server_->SetCommitClientCommand(command);
   EXPECT_TRUE(SyncShareNudge());
 
   EXPECT_EQ(TimeDelta::FromSeconds(180), last_short_poll_interval_received_);
   EXPECT_EQ(TimeDelta::FromSeconds(190), last_long_poll_interval_received_);
-  EXPECT_EQ(TimeDelta::FromSeconds(2718), last_sessions_commit_delay_);
+  EXPECT_EQ(TimeDelta::FromSeconds(2718), last_cycles_commit_delay_);
   EXPECT_EQ(TimeDelta::FromMilliseconds(1050), last_bookmarks_commit_delay_);
   EXPECT_EQ(9, last_client_invalidation_hint_buffer_size_);
 }
 
 TEST_F(SyncerTest, EnsureWeSendUpOldParent) {
   syncable::Id folder_one_id = ids_.FromNumber(1);
   syncable::Id folder_two_id = ids_.FromNumber(2);
 
   mock_server_->AddUpdateDirectory(folder_one_id, TestIdFactory::root(),
                                    "folder_one", 1, 1, foreign_cache_guid(),
@@ skipping 795 matching lines @@
 }
 
 TEST_F(SyncerTest, GetKeySuccess) {
   {
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     EXPECT_TRUE(directory()->GetNigoriHandler()->NeedKeystoreKey(&rtrans));
   }
 
   SyncShareConfigure();
 
-  EXPECT_EQ(SYNCER_OK, session_->status_controller().last_get_key_result());
+  EXPECT_EQ(SYNCER_OK, cycle_->status_controller().last_get_key_result());
   {
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     EXPECT_FALSE(directory()->GetNigoriHandler()->NeedKeystoreKey(&rtrans));
   }
 }
 
 TEST_F(SyncerTest, GetKeyEmpty) {
   {
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     EXPECT_TRUE(directory()->GetNigoriHandler()->NeedKeystoreKey(&rtrans));
   }
 
   mock_server_->SetKeystoreKey(std::string());
   SyncShareConfigure();
 
-  EXPECT_NE(SYNCER_OK, session_->status_controller().last_get_key_result());
+  EXPECT_NE(SYNCER_OK, cycle_->status_controller().last_get_key_result());
   {
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     EXPECT_TRUE(directory()->GetNigoriHandler()->NeedKeystoreKey(&rtrans));
   }
 }
 
 // Trigger an update that contains a progress marker only and verify that
 // the type's permanent folder is created and the type is marked as having
 // initial sync complete.
 TEST_F(SyncerTest, ProgressMarkerOnlyUpdateCreatesRootFolder) {
@@ skipping 411 matching lines @@
   syncable::Id local_id_;
   int64_t metahandle_;
 };
 
 TEST_F(SyncerUndeletionTest, UndeleteDuringCommit) {
   Create();
   ExpectUnsyncedCreation();
   EXPECT_TRUE(SyncShareNudge());
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Delete, begin committing the delete, then undelete while committing.
   Delete();
   ExpectUnsyncedDeletion();
   mock_server_->SetMidCommitCallback(
       base::Bind(&SyncerUndeletionTest::Undelete, base::Unretained(this)));
   EXPECT_TRUE(SyncShareNudge());
 
   // We will continue to commit until all nodes are synced, so we expect
   // that both the delete and following undelete were committed.  We haven't
   // downloaded any updates, though, so the SERVER fields will be the same
   // as they were at the start of the cycle.
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle_);
 
     // Server fields lag behind.
     EXPECT_FALSE(entry.GetServerIsDel());
 
     // We have committed the second (undelete) update.
     EXPECT_FALSE(entry.GetIsDel());
     EXPECT_FALSE(entry.GetIsUnsynced());
     EXPECT_FALSE(entry.GetIsUnappliedUpdate());
   }
 
   // Now, encounter a GetUpdates corresponding to the deletion from
   // the server.  The undeletion should prevail again and be committed.
   // None of this should trigger any conflict detection -- it is perfectly
   // normal to recieve updates from our own commits.
   mock_server_->SetMidCommitCallback(base::Closure());
   sync_pb::SyncEntity* update = mock_server_->AddUpdateFromLastCommit();
   update->set_originator_cache_guid(local_cache_guid());
   update->set_originator_client_item_id(local_id_.GetServerId());
 
   EXPECT_TRUE(SyncShareNudge());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 TEST_F(SyncerUndeletionTest, UndeleteBeforeCommit) {
   Create();
   ExpectUnsyncedCreation();
   EXPECT_TRUE(SyncShareNudge());
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Delete and undelete, then sync to pick up the result.
   Delete();
   ExpectUnsyncedDeletion();
   Undelete();
   ExpectUnsyncedEdit();  // Edit, not undelete: server thinks it exists.
   EXPECT_TRUE(SyncShareNudge());
 
   // The item ought to have committed successfully.
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle_);
     EXPECT_EQ(2, entry.GetBaseVersion());
   }
 
   // Now, encounter a GetUpdates corresponding to the just-committed
   // update.
   sync_pb::SyncEntity* update = mock_server_->AddUpdateFromLastCommit();
   update->set_originator_cache_guid(local_cache_guid());
   update->set_originator_client_item_id(local_id_.GetServerId());
   EXPECT_TRUE(SyncShareNudge());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 TEST_F(SyncerUndeletionTest, UndeleteAfterCommitButBeforeGetUpdates) {
   Create();
   ExpectUnsyncedCreation();
   EXPECT_TRUE(SyncShareNudge());
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Delete and commit.
   Delete();
   ExpectUnsyncedDeletion();
   EXPECT_TRUE(SyncShareNudge());
 
   // The item ought to have committed successfully.
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Before the GetUpdates, the item is locally undeleted.
   Undelete();
   ExpectUnsyncedUndeletion();
 
   // Now, encounter a GetUpdates corresponding to the just-committed
   // deletion update.  The undeletion should prevail.
   mock_server_->AddUpdateFromLastCommit();
   EXPECT_TRUE(SyncShareNudge());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 TEST_F(SyncerUndeletionTest, UndeleteAfterDeleteAndGetUpdates) {
   Create();
   ExpectUnsyncedCreation();
   EXPECT_TRUE(SyncShareNudge());
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   sync_pb::SyncEntity* update = mock_server_->AddUpdateFromLastCommit();
   update->set_originator_cache_guid(local_cache_guid());
   update->set_originator_client_item_id(local_id_.GetServerId());
   EXPECT_TRUE(SyncShareNudge());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Delete and commit.
   Delete();
   ExpectUnsyncedDeletion();
   EXPECT_TRUE(SyncShareNudge());
 
   // The item ought to have committed successfully.
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Now, encounter a GetUpdates corresponding to the just-committed
   // deletion update.  Should be consistent.
   mock_server_->AddUpdateFromLastCommit();
   EXPECT_TRUE(SyncShareNudge());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // After the GetUpdates, the item is locally undeleted.
   Undelete();
   ExpectUnsyncedUndeletion();
 
   // Now, encounter a GetUpdates corresponding to the just-committed
   // deletion update.  The undeletion should prevail.
   EXPECT_TRUE(SyncShareNudge());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 // Test processing of undeletion GetUpdateses.
 TEST_F(SyncerUndeletionTest, UndeleteAfterOtherClientDeletes) {
   Create();
   ExpectUnsyncedCreation();
   EXPECT_TRUE(SyncShareNudge());
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Add a delete from the server.
   sync_pb::SyncEntity* update1 = mock_server_->AddUpdateFromLastCommit();
   update1->set_originator_cache_guid(local_cache_guid());
   update1->set_originator_client_item_id(local_id_.GetServerId());
   EXPECT_TRUE(SyncShareNudge());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Some other client deletes the item.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle_);
     mock_server_->AddUpdateTombstone(entry.GetId(), PREFERENCES);
   }
   EXPECT_TRUE(SyncShareNudge());
 
   // The update ought to have applied successfully.
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Undelete it locally.
   Undelete();
   ExpectUnsyncedUndeletion();
   EXPECT_TRUE(SyncShareNudge());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 
   // Now, encounter a GetUpdates corresponding to the just-committed
   // deletion update.  The undeletion should prevail.
   sync_pb::SyncEntity* update2 = mock_server_->AddUpdateFromLastCommit();
   update2->set_originator_cache_guid(local_cache_guid());
   update2->set_originator_client_item_id(local_id_.GetServerId());
   EXPECT_TRUE(SyncShareNudge());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 TEST_F(SyncerUndeletionTest, UndeleteAfterOtherClientDeletesImmediately) {
   Create();
   ExpectUnsyncedCreation();
   EXPECT_TRUE(SyncShareNudge());
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Some other client deletes the item before we get a chance
   // to GetUpdates our original request.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle_);
     mock_server_->AddUpdateTombstone(entry.GetId(), PREFERENCES);
   }
   EXPECT_TRUE(SyncShareNudge());
 
   // The update ought to have applied successfully.
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Undelete it locally.
   Undelete();
   ExpectUnsyncedUndeletion();
   EXPECT_TRUE(SyncShareNudge());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 
   // Now, encounter a GetUpdates corresponding to the just-committed
   // deletion update.  The undeletion should prevail.
   sync_pb::SyncEntity* update = mock_server_->AddUpdateFromLastCommit();
   update->set_originator_cache_guid(local_cache_guid());
   update->set_originator_client_item_id(local_id_.GetServerId());
   EXPECT_TRUE(SyncShareNudge());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 TEST_F(SyncerUndeletionTest, OtherClientUndeletes) {
   Create();
   ExpectUnsyncedCreation();
   EXPECT_TRUE(SyncShareNudge());
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Get the updates of our just-committed entry.
   sync_pb::SyncEntity* update = mock_server_->AddUpdateFromLastCommit();
   update->set_originator_cache_guid(local_cache_guid());
   update->set_originator_client_item_id(local_id_.GetServerId());
   EXPECT_TRUE(SyncShareNudge());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // We delete the item.
   Delete();
   ExpectUnsyncedDeletion();
   EXPECT_TRUE(SyncShareNudge());
 
   // The update ought to have applied successfully.
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Now, encounter a GetUpdates corresponding to the just-committed
   // deletion update.
   mock_server_->AddUpdateFromLastCommit();
   EXPECT_TRUE(SyncShareNudge());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Some other client undeletes the item.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle_);
     mock_server_->AddUpdatePref(entry.GetId().GetServerId(),
                                 entry.GetParentId().GetServerId(), client_tag_,
                                 100, 1000);
   }
   mock_server_->SetLastUpdateClientTag(client_tag_);
   EXPECT_TRUE(SyncShareNudge());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 TEST_F(SyncerUndeletionTest, OtherClientUndeletesImmediately) {
   Create();
   ExpectUnsyncedCreation();
   EXPECT_TRUE(SyncShareNudge());
 
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // Get the updates of our just-committed entry.
   sync_pb::SyncEntity* update = mock_server_->AddUpdateFromLastCommit();
   update->set_originator_cache_guid(local_cache_guid());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle_);
     update->set_originator_client_item_id(local_id_.GetServerId());
   }
   EXPECT_TRUE(SyncShareNudge());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   ExpectSyncedAndCreated();
 
   // We delete the item.
   Delete();
   ExpectUnsyncedDeletion();
   EXPECT_TRUE(SyncShareNudge());
 
   // The update ought to have applied successfully.
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndDeleted();
 
   // Some other client undeletes before we see the update from our
   // commit.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, GET_BY_HANDLE, metahandle_);
     mock_server_->AddUpdatePref(entry.GetId().GetServerId(),
                                 entry.GetParentId().GetServerId(), client_tag_,
                                 100, 1000);
   }
   mock_server_->SetLastUpdateClientTag(client_tag_);
   EXPECT_TRUE(SyncShareNudge());
-  EXPECT_EQ(0, session_->status_controller().TotalNumConflictingItems());
+  EXPECT_EQ(0, cycle_->status_controller().TotalNumConflictingItems());
   EXPECT_EQ(1, mock_server_->GetAndClearNumGetUpdatesRequests());
   ExpectSyncedAndCreated();
 }
 
 enum {
   TEST_PARAM_BOOKMARK_ENABLE_BIT,
   TEST_PARAM_AUTOFILL_ENABLE_BIT,
   TEST_PARAM_BIT_COUNT
 };
 
@@ skipping 56 matching lines @@
     EXPECT_EQ("xyz", final_monitor_records["xyz"].extension_id);
     EXPECT_EQ(2049U, final_monitor_records["ABC"].bookmark_write_count);
     EXPECT_EQ(4U, final_monitor_records["xyz"].bookmark_write_count);
   } else {
     EXPECT_TRUE(final_monitor_records.empty())
         << "Should not restore records after successful bookmark commit.";
   }
 }
 
 }  // namespace syncer