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

components/sync/engine_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 "components/sync/engine_impl/sync_manager_impl.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/observer_list.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "components/sync/base/cancelation_signal.h"
 #include "components/sync/base/experiments.h"
 #include "components/sync/base/invalidation_interface.h"
 #include "components/sync/base/model_type.h"
-#include "components/sync/core/configure_reason.h"
-#include "components/sync/core/internal_components_factory.h"
-#include "components/sync/core_impl/model_type_connector_proxy.h"
-#include "components/sync/core_impl/syncapi_internal.h"
+#include "components/sync/engine/configure_reason.h"
+#include "components/sync/engine/engine_components_factory.h"
+#include "components/sync/engine/engine_util.h"
 #include "components/sync/engine/net/http_post_provider_factory.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/model_type_connector_proxy.h"
 #include "components/sync/engine_impl/net/sync_server_connection_manager.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/syncable/base_node.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"
@@ skipping 200 matching lines @@
       &share_, args->encryptor, args->restored_key_for_bootstrapping,
       args->restored_keystore_key_for_bootstrapping));
   sync_encryption_handler_->AddObserver(this);
   sync_encryption_handler_->AddObserver(&debug_info_event_listener_);
   sync_encryption_handler_->AddObserver(&js_sync_encryption_handler_observer_);
 
   base::FilePath absolute_db_path = database_path_;
   DCHECK(absolute_db_path.IsAbsolute());
 
   std::unique_ptr<syncable::DirectoryBackingStore> backing_store =
-      args->internal_components_factory->BuildDirectoryBackingStore(
-          InternalComponentsFactory::STORAGE_ON_DISK,
+      args->engine_components_factory->BuildDirectoryBackingStore(
+          EngineComponentsFactory::STORAGE_ON_DISK,
           args->credentials.account_id, absolute_db_path);
 
   DCHECK(backing_store.get());
   share_.directory.reset(new syncable::Directory(
       backing_store.release(), args->unrecoverable_error_handler,
       report_unrecoverable_error_function_, sync_encryption_handler_.get(),
       sync_encryption_handler_->GetCryptographerUnsafe()));
   share_.sync_credentials = args->credentials;
 
   // UserShare is accessible to a lot of code that doesn't need access to the
@@ skipping 32 matching lines @@
 
   model_type_registry_.reset(
       new ModelTypeRegistry(args->workers, directory(), this));
   sync_encryption_handler_->AddObserver(model_type_registry_.get());
 
   // 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);
-  cycle_context_ = args->internal_components_factory->BuildContext(
+  cycle_context_ = args->engine_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(
+  scheduler_ = args->engine_components_factory->BuildScheduler(
       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);
 
   NotifyInitializationSuccess();
 }
 
 void SyncManagerImpl::NotifyInitializationSuccess() {
-  FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                    OnInitializationComplete(
-                        MakeWeakHandle(weak_ptr_factory_.GetWeakPtr()),
-                        MakeWeakHandle(debug_info_event_listener_.GetWeakPtr()),
-                        true, InitialSyncEndedTypes()));
+  for (auto& observer : observers_) {
+    observer.OnInitializationComplete(
+        MakeWeakHandle(weak_ptr_factory_.GetWeakPtr()),
+        MakeWeakHandle(debug_info_event_listener_.GetWeakPtr()), true,
+        InitialSyncEndedTypes());
+  }
 }
 
 void SyncManagerImpl::NotifyInitializationFailure() {
-  FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                    OnInitializationComplete(
-                        MakeWeakHandle(weak_ptr_factory_.GetWeakPtr()),
-                        MakeWeakHandle(debug_info_event_listener_.GetWeakPtr()),
-                        false, ModelTypeSet()));
+  for (auto& observer : observers_) {
+    observer.OnInitializationComplete(
+        MakeWeakHandle(weak_ptr_factory_.GetWeakPtr()),
+        MakeWeakHandle(debug_info_event_listener_.GetWeakPtr()), false,
+        ModelTypeSet());
+  }
 }
 
 void SyncManagerImpl::OnPassphraseRequired(
     PassphraseRequiredReason reason,
     const sync_pb::EncryptedData& pending_keys) {
   // Does nothing.
 }
 
 void SyncManagerImpl::OnPassphraseAccepted() {
   // Does nothing.
@@ skipping 220 matching lines @@
 
 void SyncManagerImpl::OnNetworkConnectivityChangedImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
   scheduler_->OnConnectionStatusChange();
 }
 
 void SyncManagerImpl::OnServerConnectionEvent(
     const ServerConnectionEvent& event) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (event.connection_code == HttpResponse::SERVER_CONNECTION_OK) {
-    FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                      OnConnectionStatusChange(CONNECTION_OK));
+    for (auto& observer : observers_) {
+      observer.OnConnectionStatusChange(CONNECTION_OK);
+    }
   }
 
   if (event.connection_code == HttpResponse::SYNC_AUTH_ERROR) {
     observing_network_connectivity_changes_ = false;
-    FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                      OnConnectionStatusChange(CONNECTION_AUTH_ERROR));
+    for (auto& observer : observers_) {
+      observer.OnConnectionStatusChange(CONNECTION_AUTH_ERROR);
+    }
   }
 
   if (event.connection_code == HttpResponse::SYNC_SERVER_ERROR) {
-    FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                      OnConnectionStatusChange(CONNECTION_SERVER_ERROR));
+    for (auto& observer : observers_) {
+      observer.OnConnectionStatusChange(CONNECTION_SERVER_ERROR);
+    }
   }
 }
 
 void SyncManagerImpl::HandleTransactionCompleteChangeEvent(
     ModelTypeSet models_with_changes) {
   // This notification happens immediately after the transaction mutex is
   // released. This allows work to be performed without blocking other threads
   // from acquiring a transaction.
   if (!change_delegate_)
     return;
@@ skipping 205 matching lines @@
   // Notifications are sent at the end of every sync cycle, regardless of
   // whether we should sync again.
   if (event.what_happened == SyncCycleEvent::SYNC_CYCLE_ENDED) {
     if (!initialized_) {
       DVLOG(1) << "OnSyncCycleCompleted not sent because sync api is not "
                << "initialized";
       return;
     }
 
     DVLOG(1) << "Sending OnSyncCycleCompleted";
-    FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                      OnSyncCycleCompleted(event.snapshot));
+    for (auto& observer : observers_) {
+      observer.OnSyncCycleCompleted(event.snapshot);
+    }
   }
 }
 
 void SyncManagerImpl::OnActionableError(const SyncProtocolError& error) {
-  FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                    OnActionableError(error));
+  for (auto& observer : observers_) {
+    observer.OnActionableError(error);
+  }
 }
 
 void SyncManagerImpl::OnRetryTimeChanged(base::Time) {}
 
 void SyncManagerImpl::OnThrottledTypesChanged(ModelTypeSet) {}
 
 void SyncManagerImpl::OnMigrationRequested(ModelTypeSet types) {
-  FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                    OnMigrationRequested(types));
+  for (auto& observer : observers_) {
+    observer.OnMigrationRequested(types);
+  }
 }
 
 void SyncManagerImpl::OnProtocolEvent(const ProtocolEvent& event) {
   protocol_event_buffer_.RecordProtocolEvent(event);
-  FOR_EACH_OBSERVER(SyncManager::Observer, observers_, OnProtocolEvent(event));
+  for (auto& observer : observers_) {
+    observer.OnProtocolEvent(event);
+  }
 }
 
 void SyncManagerImpl::SetJsEventHandler(
     const WeakHandle<JsEventHandler>& event_handler) {
   js_sync_manager_observer_.SetJsEventHandler(event_handler);
   js_mutation_event_observer_.SetJsEventHandler(event_handler);
   js_sync_encryption_handler_observer_.SetJsEventHandler(event_handler);
 }
 
 void SyncManagerImpl::SetInvalidatorEnabled(bool invalidator_enabled) {
@@ skipping 133 matching lines @@
 }
 
 void SyncManagerImpl::OnCookieJarChanged(bool account_mismatch,
                                          bool empty_jar) {
   DCHECK(thread_checker_.CalledOnValidThread());
   cycle_context_->set_cookie_jar_mismatch(account_mismatch);
   cycle_context_->set_cookie_jar_empty(empty_jar);
 }
 
 }  // namespace syncer