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

components/sync/core_impl/sync_manager_impl_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.
 
 // Unit tests for the SyncApi. Note that a lot of the underlying
 // functionality is provided by the Syncable layer, which has its own
 // unit tests. We'll test SyncApi specific things in this harness.
 
 #include "components/sync/core_impl/sync_manager_impl.h"
 
@@ skipping 31 matching lines @@
 #include "components/sync/core/test/test_entry_factory.h"
 #include "components/sync/core/test/test_internal_components_factory.h"
 #include "components/sync/core/test/test_user_share.h"
 #include "components/sync/core/write_node.h"
 #include "components/sync/core/write_transaction.h"
 #include "components/sync/core_impl/sync_encryption_handler_impl.h"
 #include "components/sync/core_impl/syncapi_internal.h"
 #include "components/sync/engine/events/protocol_event.h"
 #include "components/sync/engine/model_safe_worker.h"
 #include "components/sync/engine/polling_constants.h"
+#include "components/sync/engine_impl/cycle/sync_cycle.h"
 #include "components/sync/engine_impl/sync_scheduler.h"
 #include "components/sync/js/js_backend.h"
 #include "components/sync/js/js_event_handler.h"
 #include "components/sync/js/js_test_util.h"
 #include "components/sync/protocol/bookmark_specifics.pb.h"
 #include "components/sync/protocol/encryption.pb.h"
 #include "components/sync/protocol/extension_specifics.pb.h"
 #include "components/sync/protocol/password_specifics.pb.h"
 #include "components/sync/protocol/preference_specifics.pb.h"
 #include "components/sync/protocol/proto_value_conversions.h"
 #include "components/sync/protocol/sync.pb.h"
-#include "components/sync/sessions_impl/sync_session.h"
 #include "components/sync/syncable/directory.h"
 #include "components/sync/syncable/entry.h"
 #include "components/sync/syncable/mutable_entry.h"
 #include "components/sync/syncable/nigori_util.h"
 #include "components/sync/syncable/syncable_id.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/callback_counter.h"
 #include "components/sync/test/engine/fake_model_worker.h"
 #include "components/sync/test/engine/fake_sync_scheduler.h"
 #include "components/sync/test/engine/test_id_factory.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/protobuf/src/google/protobuf/io/coded_stream.h"
 #include "third_party/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.h"
 #include "url/gurl.h"
 
 using base::ExpectDictStringValue;
 using testing::_;
 using testing::DoAll;
 using testing::InSequence;
 using testing::Return;
 using testing::SaveArg;
 using testing::StrictMock;
 
 namespace syncer {
 
-using sessions::SyncSessionSnapshot;
 using syncable::GET_BY_HANDLE;
 using syncable::IS_DEL;
 using syncable::IS_UNSYNCED;
 using syncable::NON_UNIQUE_NAME;
 using syncable::SPECIFICS;
 using syncable::kEncryptedString;
 
 namespace {
 
 // Makes a child node under the type root folder.  Returns the id of the
@@ skipping 783 matching lines @@
   HttpPostProviderInterface* Create() override {
     return new TestHttpPostProviderInterface();
   }
   void Destroy(HttpPostProviderInterface* http) override {
     delete static_cast<TestHttpPostProviderInterface*>(http);
   }
 };
 
 class SyncManagerObserverMock : public SyncManager::Observer {
  public:
-  MOCK_METHOD1(OnSyncCycleCompleted,
-               void(const SyncSessionSnapshot&));  // NOLINT
+  MOCK_METHOD1(OnSyncCycleCompleted, void(const SyncCycleSnapshot&));  // NOLINT
   MOCK_METHOD4(OnInitializationComplete,
                void(const WeakHandle<JsBackend>&,
                     const WeakHandle<DataTypeDebugInfoListener>&,
                     bool,
                     syncer::ModelTypeSet));                         // NOLINT
   MOCK_METHOD1(OnConnectionStatusChange, void(ConnectionStatus));   // NOLINT
   MOCK_METHOD1(OnUpdatedToken, void(const std::string&));           // NOLINT
   MOCK_METHOD1(OnActionableError, void(const SyncProtocolError&));  // NOLINT
   MOCK_METHOD1(OnMigrationRequested, void(syncer::ModelTypeSet));   // NOLINT
   MOCK_METHOD1(OnProtocolEvent, void(const ProtocolEvent&));        // NOLINT
@@ skipping 1620 matching lines @@
   virtual ~MockSyncScheduler() {}
 
   MOCK_METHOD2(Start, void(SyncScheduler::Mode, base::Time));
   MOCK_METHOD1(ScheduleConfiguration, void(const ConfigurationParams&));
 };
 
 class ComponentsFactory : public TestInternalComponentsFactory {
  public:
   ComponentsFactory(const Switches& switches,
                     SyncScheduler* scheduler_to_use,
-                    sessions::SyncSessionContext** session_context,
+                    SyncCycleContext** cycle_context,
                     InternalComponentsFactory::StorageOption* storage_used)
       : TestInternalComponentsFactory(
             switches,
             InternalComponentsFactory::STORAGE_IN_MEMORY,
             storage_used),
         scheduler_to_use_(scheduler_to_use),
-        session_context_(session_context) {}
+        cycle_context_(cycle_context) {}
   ~ComponentsFactory() override {}
 
   std::unique_ptr<SyncScheduler> BuildScheduler(
       const std::string& name,
-      sessions::SyncSessionContext* context,
+      SyncCycleContext* context,
       CancelationSignal* stop_handle) override {
-    *session_context_ = context;
+    *cycle_context_ = context;
     return std::move(scheduler_to_use_);
   }
 
  private:
   std::unique_ptr<SyncScheduler> scheduler_to_use_;
-  sessions::SyncSessionContext** session_context_;
+  SyncCycleContext** cycle_context_;
 };
 
 class SyncManagerTestWithMockScheduler : public SyncManagerTest {
  public:
   SyncManagerTestWithMockScheduler() : scheduler_(NULL) {}
   InternalComponentsFactory* GetFactory() override {
     scheduler_ = new MockSyncScheduler();
-    return new ComponentsFactory(GetSwitches(), scheduler_, &session_context_,
+    return new ComponentsFactory(GetSwitches(), scheduler_, &cycle_context_,
                                  &storage_used_);
   }
 
   MockSyncScheduler* scheduler() { return scheduler_; }
-  sessions::SyncSessionContext* session_context() { return session_context_; }
+  SyncCycleContext* cycle_context() { return cycle_context_; }
 
  private:
   MockSyncScheduler* scheduler_;
-  sessions::SyncSessionContext* session_context_;
+  SyncCycleContext* cycle_context_;
 };
 
 // Test that the configuration params are properly created and sent to
 // ScheduleConfigure. No callback should be invoked. Any disabled datatypes
 // should be purged.
 TEST_F(SyncManagerTestWithMockScheduler, BasicConfiguration) {
   ConfigureReason reason = CONFIGURE_REASON_RECONFIGURATION;
   ModelTypeSet types_to_download(BOOKMARKS, PREFERENCES);
   ModelSafeRoutingInfo new_routing_info;
   GetModelSafeRoutingInfo(&new_routing_info);
@@ skipping 57 matching lines @@
   for (ModelTypeSet::Iterator iter = protocol_types.First(); iter.Good();
        iter.Inc()) {
     if (!disabled_types.Has(iter.Get())) {
       SetProgressMarkerForType(iter.Get(), true);
     } else {
       SetProgressMarkerForType(iter.Get(), false);
     }
   }
 
   // Set the context to have the old routing info.
-  session_context()->SetRoutingInfo(old_routing_info);
+  cycle_context()->SetRoutingInfo(old_routing_info);
 
   CallbackCounter ready_task_counter, retry_task_counter;
   sync_manager_.ConfigureSyncer(
       reason, types_to_download, ModelTypeSet(), ModelTypeSet(), ModelTypeSet(),
       new_routing_info, base::Bind(&CallbackCounter::Callback,
                                    base::Unretained(&ready_task_counter)),
       base::Bind(&CallbackCounter::Callback,
                  base::Unretained(&retry_task_counter)));
   EXPECT_EQ(0, ready_task_counter.times_called());
   EXPECT_EQ(0, retry_task_counter.times_called());
@@ skipping 677 matching lines @@
 // SyncManagerInitInvalidStorageTest::GetFactory will return
 // DirectoryBackingStore that ensures that SyncManagerImpl::OpenDirectory fails.
 // SyncManagerImpl initialization is done in SyncManagerTest::SetUp. This test's
 // task is to ensure that SyncManagerImpl reported initialization failure in
 // OnInitializationComplete callback.
 TEST_F(SyncManagerInitInvalidStorageTest, FailToOpenDatabase) {
   EXPECT_FALSE(initialization_succeeded_);
 }
 
 }  // namespace syncer