[Sync] Move the last things out of core/.

components/sync/engine_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"
+#include "components/sync/engine_impl/sync_manager_impl.h"
 
 #include <cstddef>
 #include <memory>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/values_test_util.h"
 #include "base/values.h"
 #include "components/sync/base/attachment_id_proto.h"
 #include "components/sync/base/cancelation_signal.h"
 #include "components/sync/base/extensions_activity.h"
 #include "components/sync/base/fake_encryptor.h"
 #include "components/sync/base/mock_unrecoverable_error_handler.h"
 #include "components/sync/base/model_type_test_util.h"
-#include "components/sync/core/test/test_entry_factory.h"
-#include "components/sync/core/test/test_internal_components_factory.h"
-#include "components/sync/core_impl/syncapi_internal.h"
+#include "components/sync/engine/engine_util.h"
 #include "components/sync/engine/events/protocol_event.h"
 #include "components/sync/engine/model_safe_worker.h"
 #include "components/sync/engine/net/http_post_provider_factory.h"
 #include "components/sync/engine/net/http_post_provider_interface.h"
 #include "components/sync/engine/polling_constants.h"
+#include "components/sync/engine/test_engine_components_factory.h"
 #include "components/sync/engine_impl/cycle/sync_cycle.h"
 #include "components/sync/engine_impl/sync_scheduler.h"
+#include "components/sync/engine_impl/test_entry_factory.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/syncable/change_record.h"
@@ skipping 882 matching lines @@
 }  // namespace
 
 class SyncManagerTest : public testing::Test,
                         public SyncManager::ChangeDelegate {
  protected:
   enum NigoriStatus { DONT_WRITE_NIGORI, WRITE_TO_NIGORI };
 
   enum EncryptionStatus { UNINITIALIZED, DEFAULT_ENCRYPTION, FULL_ENCRYPTION };
 
   SyncManagerTest() : sync_manager_("Test sync manager") {
-    switches_.encryption_method =
-        InternalComponentsFactory::ENCRYPTION_KEYSTORE;
+    switches_.encryption_method = EngineComponentsFactory::ENCRYPTION_KEYSTORE;
   }
 
   virtual ~SyncManagerTest() {}
 
   // Test implementation.
   void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     extensions_activity_ = new ExtensionsActivity();
 
@@ skipping 25 matching lines @@
     SyncManager::InitArgs args;
     args.database_location = temp_dir_.GetPath();
     args.service_url = GURL("https://example.com/");
     args.post_factory = std::unique_ptr<HttpPostProviderFactory>(
         new TestHttpPostProviderFactory());
     args.workers = workers;
     args.extensions_activity = extensions_activity_.get(),
     args.change_delegate = this;
     args.credentials = credentials;
     args.invalidator_client_id = "fake_invalidator_client_id";
-    args.internal_components_factory.reset(GetFactory());
+    args.engine_components_factory.reset(GetFactory());
     args.encryptor = &encryptor_;
     args.unrecoverable_error_handler =
         MakeWeakHandle(mock_unrecoverable_error_handler_.GetWeakPtr());
     args.cancelation_signal = &cancelation_signal_;
     sync_manager_.Init(&args);
 
     sync_manager_.GetEncryptionHandler()->AddObserver(&encryption_observer_);
 
     EXPECT_TRUE(js_backend_.IsInitialized());
-    EXPECT_EQ(InternalComponentsFactory::STORAGE_ON_DISK, storage_used_);
+    EXPECT_EQ(EngineComponentsFactory::STORAGE_ON_DISK, storage_used_);
 
     if (initialization_succeeded_) {
       for (ModelSafeRoutingInfo::iterator i = routing_info.begin();
            i != routing_info.end(); ++i) {
         type_roots_[i->first] =
             MakeTypeRoot(sync_manager_.GetUserShare(), i->first);
       }
     }
 
     PumpLoop();
@@ skipping 89 matching lines @@
                                      share->directory.get());
     const std::string hash = syncable::GenerateSyncableHash(type, client_tag);
     syncable::MutableEntry entry(&trans, syncable::GET_BY_CLIENT_TAG, hash);
     EXPECT_TRUE(entry.good());
     if (!entry.GetIsUnsynced())
       return false;
     entry.PutIsUnsynced(false);
     return true;
   }
 
-  virtual InternalComponentsFactory* GetFactory() {
-    return new TestInternalComponentsFactory(
-        GetSwitches(), InternalComponentsFactory::STORAGE_IN_MEMORY,
+  virtual EngineComponentsFactory* GetFactory() {
+    return new TestEngineComponentsFactory(
+        GetSwitches(), EngineComponentsFactory::STORAGE_IN_MEMORY,
         &storage_used_);
   }
 
   // Returns true if we are currently encrypting all sync data.  May
   // be called on any thread.
   bool IsEncryptEverythingEnabledForTest() {
     return sync_manager_.GetEncryptionHandler()->IsEncryptEverythingEnabled();
   }
 
   // Gets the set of encrypted types from the cryptographer
@@ skipping 28 matching lines @@
       sync_pb::DataTypeProgressMarker marker;
       marker.set_token("token");
       marker.set_data_type_id(GetSpecificsFieldNumberFromModelType(type));
       sync_manager_.directory()->SetDownloadProgress(type, marker);
     } else {
       sync_pb::DataTypeProgressMarker marker;
       sync_manager_.directory()->SetDownloadProgress(type, marker);
     }
   }
 
-  InternalComponentsFactory::Switches GetSwitches() const { return switches_; }
+  EngineComponentsFactory::Switches GetSwitches() const { return switches_; }
 
   void ExpectPassphraseAcceptance() {
     EXPECT_CALL(encryption_observer_, OnPassphraseAccepted());
     EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
     EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
   }
 
   void SetImplicitPassphraseAndCheck(const std::string& passphrase) {
     sync_manager_.GetEncryptionHandler()->SetEncryptionPassphrase(passphrase,
                                                                   false);
@@ skipping 22 matching lines @@
   scoped_refptr<ExtensionsActivity> extensions_activity_;
 
  protected:
   FakeEncryptor encryptor_;
   SyncManagerImpl sync_manager_;
   CancelationSignal cancelation_signal_;
   WeakHandle<JsBackend> js_backend_;
   bool initialization_succeeded_;
   StrictMock<SyncManagerObserverMock> manager_observer_;
   StrictMock<SyncEncryptionHandlerObserverMock> encryption_observer_;
-  InternalComponentsFactory::Switches switches_;
-  InternalComponentsFactory::StorageOption storage_used_;
+  EngineComponentsFactory::Switches switches_;
+  EngineComponentsFactory::StorageOption storage_used_;
   MockUnrecoverableErrorHandler mock_unrecoverable_error_handler_;
 };
 
 TEST_F(SyncManagerTest, RefreshEncryptionReady) {
   EXPECT_TRUE(SetUpEncryption(WRITE_TO_NIGORI, DEFAULT_ENCRYPTION));
   EXPECT_CALL(encryption_observer_, OnEncryptionComplete());
   EXPECT_CALL(encryption_observer_, OnCryptographerStateChanged(_));
   EXPECT_CALL(encryption_observer_, OnEncryptedTypesChanged(_, false));
 
   sync_manager_.GetEncryptionHandler()->Init();
@@ skipping 1318 matching lines @@
 
 class MockSyncScheduler : public FakeSyncScheduler {
  public:
   MockSyncScheduler() : FakeSyncScheduler() {}
   virtual ~MockSyncScheduler() {}
 
   MOCK_METHOD2(Start, void(SyncScheduler::Mode, base::Time));
   MOCK_METHOD1(ScheduleConfiguration, void(const ConfigurationParams&));
 };
 
-class ComponentsFactory : public TestInternalComponentsFactory {
+class ComponentsFactory : public TestEngineComponentsFactory {
  public:
   ComponentsFactory(const Switches& switches,
                     SyncScheduler* scheduler_to_use,
                     SyncCycleContext** cycle_context,
-                    InternalComponentsFactory::StorageOption* storage_used)
-      : TestInternalComponentsFactory(
-            switches,
-            InternalComponentsFactory::STORAGE_IN_MEMORY,
-            storage_used),
+                    EngineComponentsFactory::StorageOption* storage_used)
+      : TestEngineComponentsFactory(switches,
+                                    EngineComponentsFactory::STORAGE_IN_MEMORY,
+                                    storage_used),
         scheduler_to_use_(scheduler_to_use),
         cycle_context_(cycle_context) {}
   ~ComponentsFactory() override {}
 
   std::unique_ptr<SyncScheduler> BuildScheduler(
       const std::string& name,
       SyncCycleContext* context,
       CancelationSignal* stop_handle) override {
     *cycle_context_ = context;
     return std::move(scheduler_to_use_);
   }
 
  private:
   std::unique_ptr<SyncScheduler> scheduler_to_use_;
   SyncCycleContext** cycle_context_;
 };
 
 class SyncManagerTestWithMockScheduler : public SyncManagerTest {
  public:
   SyncManagerTestWithMockScheduler() : scheduler_(NULL) {}
-  InternalComponentsFactory* GetFactory() override {
+  EngineComponentsFactory* GetFactory() override {
     scheduler_ = new MockSyncScheduler();
     return new ComponentsFactory(GetSwitches(), scheduler_, &cycle_context_,
                                  &storage_used_);
   }
 
   MockSyncScheduler* scheduler() { return scheduler_; }
   SyncCycleContext* cycle_context() { return cycle_context_; }
 
  private:
   MockSyncScheduler* scheduler_;
@@ skipping 743 matching lines @@
                                      share()->directory.get());
     syncable::MutableEntry article(&trans, syncable::GET_BY_HANDLE, article_id);
     article.PutAttachmentMetadata(article.GetAttachmentMetadata());
   }
   ASSERT_EQ(0UL, GetChangeListSize());
 }
 
 // During initialization SyncManagerImpl loads sqlite database. If it fails to
 // do so it should fail initialization. This test verifies this behavior.
 // Test reuses SyncManagerImpl initialization from SyncManagerTest but overrides
-// InternalComponentsFactory to return DirectoryBackingStore that always fails
+// EngineComponentsFactory to return DirectoryBackingStore that always fails
 // to load.
 class SyncManagerInitInvalidStorageTest : public SyncManagerTest {
  public:
   SyncManagerInitInvalidStorageTest() {}
 
-  InternalComponentsFactory* GetFactory() override {
-    return new TestInternalComponentsFactory(
-        GetSwitches(), InternalComponentsFactory::STORAGE_INVALID,
+  EngineComponentsFactory* GetFactory() override {
+    return new TestEngineComponentsFactory(
+        GetSwitches(), EngineComponentsFactory::STORAGE_INVALID,
         &storage_used_);
   }
 };
 
 // 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