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

components/sync/driver/glue/sync_backend_host_core.cc

 // Copyright 2013 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/driver/glue/sync_backend_host_core.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "components/invalidation/public/invalidation_util.h"
 #include "components/invalidation/public/object_id_invalidation_map.h"
 #include "components/sync/base/invalidation_adapter.h"
-#include "components/sync/core/internal_components_factory.h"
-#include "components/sync/core/sync_manager.h"
-#include "components/sync/core/sync_manager_factory.h"
 #include "components/sync/device_info/local_device_info_provider_impl.h"
 #include "components/sync/driver/glue/sync_backend_registrar.h"
 #include "components/sync/engine/cycle/commit_counters.h"
 #include "components/sync/engine/cycle/status_counters.h"
 #include "components/sync/engine/cycle/sync_cycle_snapshot.h"
 #include "components/sync/engine/cycle/update_counters.h"
+#include "components/sync/engine/engine_components_factory.h"
 #include "components/sync/engine/events/protocol_event.h"
 #include "components/sync/engine/net/http_post_provider_factory.h"
+#include "components/sync/engine/sync_manager.h"
+#include "components/sync/engine/sync_manager_factory.h"
 
 // Helper macros to log with the syncer thread name; useful when there
 // are multiple syncers involved.
 
 #define SLOG(severity) LOG(severity) << name_ << ": "
 
 #define SDVLOG(verbose_level) DVLOG(verbose_level) << name_ << ": "
 
 static const int kSaveChangesIntervalSeconds = 10;
 
-namespace syncer {
-class InternalComponentsFactory;
-}  // namespace syncer
-
 namespace net {
 class URLFetcher;
 }
 
 namespace {
 
 void BindFetcherToDataTracker(net::URLFetcher* fetcher) {
   data_use_measurement::DataUseUserData::AttachToFetcher(
       fetcher, data_use_measurement::DataUseUserData::SYNC);
 }
 
 }  // namespace
 
 namespace syncer {
 
+class EngineComponentsFactory;
+
 DoInitializeOptions::DoInitializeOptions(
     base::MessageLoop* sync_loop,
     SyncBackendRegistrar* registrar,
     const std::vector<scoped_refptr<ModelSafeWorker>>& workers,
     const scoped_refptr<ExtensionsActivity>& extensions_activity,
     const WeakHandle<JsEventHandler>& event_handler,
     const GURL& service_url,
     const std::string& sync_user_agent,
     std::unique_ptr<HttpPostProviderFactory> http_bridge_factory,
     const SyncCredentials& credentials,
     const std::string& invalidator_client_id,
     std::unique_ptr<SyncManagerFactory> sync_manager_factory,
     bool delete_sync_data_folder,
     const std::string& restored_key_for_bootstrapping,
     const std::string& restored_keystore_key_for_bootstrapping,
-    std::unique_ptr<InternalComponentsFactory> internal_components_factory,
+    std::unique_ptr<EngineComponentsFactory> engine_components_factory,
     const WeakHandle<UnrecoverableErrorHandler>& unrecoverable_error_handler,
     const base::Closure& report_unrecoverable_error_function,
     std::unique_ptr<SyncEncryptionHandler::NigoriState> saved_nigori_state,
     const std::map<ModelType, int64_t>& invalidation_versions)
     : sync_loop(sync_loop),
       registrar(registrar),
       workers(workers),
       extensions_activity(extensions_activity),
       event_handler(event_handler),
       service_url(service_url),
       sync_user_agent(sync_user_agent),
       http_bridge_factory(std::move(http_bridge_factory)),
       credentials(credentials),
       invalidator_client_id(invalidator_client_id),
       sync_manager_factory(std::move(sync_manager_factory)),
       delete_sync_data_folder(delete_sync_data_folder),
       restored_key_for_bootstrapping(restored_key_for_bootstrapping),
       restored_keystore_key_for_bootstrapping(
           restored_keystore_key_for_bootstrapping),
-      internal_components_factory(std::move(internal_components_factory)),
+      engine_components_factory(std::move(engine_components_factory)),
       unrecoverable_error_handler(unrecoverable_error_handler),
       report_unrecoverable_error_function(report_unrecoverable_error_function),
       saved_nigori_state(std::move(saved_nigori_state)),
       invalidation_versions(invalidation_versions) {}
 
 DoInitializeOptions::~DoInitializeOptions() {}
 
 DoConfigureSyncerTypes::DoConfigureSyncerTypes() {}
 
 DoConfigureSyncerTypes::DoConfigureSyncerTypes(
@@ skipping 307 matching lines @@
   args.service_url = options->service_url;
   args.post_factory = std::move(options->http_bridge_factory);
   args.workers = options->workers;
   args.extensions_activity = options->extensions_activity.get();
   args.change_delegate = options->registrar;  // as SyncManager::ChangeDelegate
   args.credentials = options->credentials;
   args.invalidator_client_id = options->invalidator_client_id;
   args.restored_key_for_bootstrapping = options->restored_key_for_bootstrapping;
   args.restored_keystore_key_for_bootstrapping =
       options->restored_keystore_key_for_bootstrapping;
-  args.internal_components_factory =
-      std::move(options->internal_components_factory);
+  args.engine_components_factory =
+      std::move(options->engine_components_factory);
   args.encryptor = &encryptor_;
   args.unrecoverable_error_handler = options->unrecoverable_error_handler;
   args.report_unrecoverable_error_function =
       options->report_unrecoverable_error_function;
   args.cancelation_signal = &stop_syncing_signal_;
   args.saved_nigori_state = std::move(options->saved_nigori_state);
   sync_manager_->Init(&args);
 }
 
 void SyncBackendHostCore::DoUpdateCredentials(
@@ skipping 251 matching lines @@
 }
 
 void SyncBackendHostCore::ClearServerDataDone(
     const base::Closure& frontend_callback) {
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   host_.Call(FROM_HERE, &SyncBackendHostImpl::ClearServerDataDoneOnFrontendLoop,
              frontend_callback);
 }
 
 }  // namespace syncer