[Sync] Move //components/sync_driver to //components/sync/driver.

components/sync/driver/glue/sync_backend_host_impl.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_impl.h"
+#include "components/sync/driver/glue/sync_backend_host_impl.h"
 
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/invalidation/public/invalidation_service.h"
 #include "components/invalidation/public/object_id_invalidation_map.h"
 #include "components/signin/core/browser/signin_client.h"
 #include "components/sync/base/experiments.h"
 #include "components/sync/base/sync_string_conversions.h"
 #include "components/sync/core/activation_context.h"
 #include "components/sync/core/base_transaction.h"
 #include "components/sync/core/http_bridge.h"
 #include "components/sync/core/internal_components_factory.h"
 #include "components/sync/core/internal_components_factory_impl.h"
 #include "components/sync/core/sync_manager.h"
 #include "components/sync/core/sync_manager_factory.h"
+#include "components/sync/driver/glue/sync_backend_host_core.h"
+#include "components/sync/driver/glue/sync_backend_registrar.h"
+#include "components/sync/driver/invalidation_helper.h"
+#include "components/sync/driver/sync_client.h"
+#include "components/sync/driver/sync_driver_switches.h"
+#include "components/sync/driver/sync_frontend.h"
+#include "components/sync/driver/sync_prefs.h"
 #include "components/sync/engine/events/protocol_event.h"
-#include "components/sync_driver/glue/sync_backend_host_core.h"
-#include "components/sync_driver/glue/sync_backend_registrar.h"
-#include "components/sync_driver/invalidation_helper.h"
-#include "components/sync_driver/sync_client.h"
-#include "components/sync_driver/sync_driver_switches.h"
-#include "components/sync_driver/sync_frontend.h"
-#include "components/sync_driver/sync_prefs.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_ << ": "
 
 using syncer::InternalComponentsFactory;
 
@@ skipping 45 matching lines @@
     std::unique_ptr<syncer::SyncEncryptionHandler::NigoriState>
         saved_nigori_state) {
   registrar_.reset(new browser_sync::SyncBackendRegistrar(
       name_, sync_client_, std::move(sync_thread), ui_thread_, db_thread,
       file_thread));
   CHECK(registrar_->sync_thread());
 
   frontend_ = frontend;
   DCHECK(frontend);
 
-  std::vector<scoped_refptr<syncer::ModelSafeWorker> > workers;
+  std::vector<scoped_refptr<syncer::ModelSafeWorker>> workers;
   registrar_->GetWorkers(&workers);
 
   InternalComponentsFactory::Switches factory_switches = {
-    InternalComponentsFactory::ENCRYPTION_KEYSTORE,
-    InternalComponentsFactory::BACKOFF_NORMAL
-  };
+      InternalComponentsFactory::ENCRYPTION_KEYSTORE,
+      InternalComponentsFactory::BACKOFF_NORMAL};
 
   base::CommandLine* cl = base::CommandLine::ForCurrentProcess();
   if (cl->HasSwitch(switches::kSyncShortInitialRetryOverride)) {
     factory_switches.backoff_override =
         InternalComponentsFactory::BACKOFF_SHORT_INITIAL_RETRY_OVERRIDE;
   }
   if (cl->HasSwitch(switches::kSyncEnableGetUpdateAvoidance)) {
     factory_switches.pre_commit_updates_policy =
         InternalComponentsFactory::FORCE_ENABLE_PRE_COMMIT_UPDATE_AVOIDANCE;
   }
@@ skipping 206 matching lines @@
 
   disabled_types.PutAll(fatal_types);
   disabled_types.PutAll(crypto_types);
   disabled_types.PutAll(unready_types);
 
   syncer::ModelTypeSet active_types =
       GetDataTypesInState(CONFIGURE_ACTIVE, config_state_map);
   syncer::ModelTypeSet clean_first_types =
       GetDataTypesInState(CONFIGURE_CLEAN, config_state_map);
   syncer::ModelTypeSet types_to_download = registrar_->ConfigureDataTypes(
-      syncer::Union(active_types, clean_first_types),
-      disabled_types);
+      syncer::Union(active_types, clean_first_types), disabled_types);
   types_to_download.PutAll(clean_first_types);
   types_to_download.RemoveAll(syncer::ProxyTypes());
   if (!types_to_download.Empty())
     types_to_download.Put(syncer::NIGORI);
 
   // TODO(sync): crbug.com/137550.
   // It's dangerous to configure types that have progress markers.  Types with
   // progress markers can trigger a MIGRATION_DONE response.  We are not
   // prepared to handle a migration during a configure, so we must ensure that
   // all our types_to_download actually contain no data before we sync them.
@@ skipping 30 matching lines @@
   // to be acted on again.
   fatal_types.RetainAll(types_to_purge);
   syncer::ModelTypeSet unapply_types =
       syncer::Union(crypto_types, clean_first_types);
   unapply_types.RetainAll(types_to_purge);
 
   DCHECK(syncer::Intersection(current_types, fatal_types).Empty());
   DCHECK(syncer::Intersection(current_types, crypto_types).Empty());
   DCHECK(current_types.HasAll(types_to_download));
 
-  SDVLOG(1) << "Types "
-            << syncer::ModelTypeSetToString(types_to_download)
+  SDVLOG(1) << "Types " << syncer::ModelTypeSetToString(types_to_download)
             << " added; calling DoConfigureSyncer";
   // Divide up the types into their corresponding actions (each is mutually
   // exclusive):
   // - Types which have just been added to the routing info (types_to_download):
   //   are downloaded.
   // - Types which have encountered a fatal error (fatal_types) are deleted
   //   from the directory and journaled in the delete journal.
   // - Types which have encountered a cryptographer error (crypto_types) are
   //   unapplied (local state is purged but sync state is not).
   // - All other types not in the routing info (types just disabled) are deleted
   //   from the directory.
   // - Everything else (enabled types and already disabled types) is not
   //   touched.
-  RequestConfigureSyncer(reason,
-                         types_to_download,
-                         types_to_purge,
-                         fatal_types,
-                         unapply_types,
-                         inactive_types,
-                         routing_info,
-                         ready_task,
-                         retry_callback);
+  RequestConfigureSyncer(reason, types_to_download, types_to_purge, fatal_types,
+                         unapply_types, inactive_types, routing_info,
+                         ready_task, retry_callback);
 
   DCHECK(syncer::Intersection(active_types, types_to_purge).Empty());
   DCHECK(syncer::Intersection(active_types, fatal_types).Empty());
   DCHECK(syncer::Intersection(active_types, unapply_types).Empty());
   DCHECK(syncer::Intersection(active_types, inactive_types).Empty());
   return syncer::Difference(active_types, types_to_download);
 }
 
 void SyncBackendHostImpl::EnableEncryptEverything() {
   registrar_->sync_thread()->task_runner()->PostTask(
@@ skipping 53 matching lines @@
   return cached_passphrase_type_;
 }
 
 base::Time SyncBackendHostImpl::GetExplicitPassphraseTime() const {
   return cached_explicit_passphrase_time_;
 }
 
 bool SyncBackendHostImpl::IsCryptographerReady(
     const syncer::BaseTransaction* trans) const {
   return initialized() && trans->GetCryptographer() &&
-      trans->GetCryptographer()->is_ready();
+         trans->GetCryptographer()->is_ready();
 }
 
 void SyncBackendHostImpl::GetModelSafeRoutingInfo(
     syncer::ModelSafeRoutingInfo* out) const {
   if (initialized()) {
     CHECK(registrar_.get());
     registrar_->GetModelSafeRoutingInfo(out);
   } else {
     NOTREACHED();
   }
@@ skipping 53 matching lines @@
 }
 
 void SyncBackendHostImpl::RequestConfigureSyncer(
     syncer::ConfigureReason reason,
     syncer::ModelTypeSet to_download,
     syncer::ModelTypeSet to_purge,
     syncer::ModelTypeSet to_journal,
     syncer::ModelTypeSet to_unapply,
     syncer::ModelTypeSet to_ignore,
     const syncer::ModelSafeRoutingInfo& routing_info,
-    const base::Callback<void(syncer::ModelTypeSet,
-                              syncer::ModelTypeSet)>& ready_task,
+    const base::Callback<void(syncer::ModelTypeSet, syncer::ModelTypeSet)>&
+        ready_task,
     const base::Closure& retry_callback) {
   DoConfigureSyncerTypes config_types;
   config_types.to_download = to_download;
   config_types.to_purge = to_purge;
   config_types.to_journal = to_journal;
   config_types.to_unapply = to_unapply;
   registrar_->sync_thread()->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&SyncBackendHostCore::DoConfigureSyncer, core_.get(), reason,
                  config_types, routing_info, ready_task, retry_callback));
 }
 
 void SyncBackendHostImpl::FinishConfigureDataTypesOnFrontendLoop(
     const syncer::ModelTypeSet enabled_types,
     const syncer::ModelTypeSet succeeded_configuration_types,
     const syncer::ModelTypeSet failed_configuration_types,
-    const base::Callback<void(syncer::ModelTypeSet,
-                              syncer::ModelTypeSet)>& ready_task) {
+    const base::Callback<void(syncer::ModelTypeSet, syncer::ModelTypeSet)>&
+        ready_task) {
   if (!frontend_)
     return;
 
   if (invalidator_) {
     CHECK(invalidator_->UpdateRegisteredInvalidationIds(
         this, ModelTypeSetToObjectIdSet(enabled_types)));
   }
 
   if (!ready_task.is_null())
     ready_task.Run(succeeded_configuration_types, failed_configuration_types);
@@ skipping 27 matching lines @@
 
     // Fake a state change to initialize the SyncManager's cached invalidator
     // state.
     OnInvalidatorStateChange(invalidator_->GetInvalidatorState());
   }
 
   // Now that we've downloaded the control types, we can see if there are any
   // experimental types to enable. This should be done before we inform
   // the frontend to ensure they're visible in the customize screen.
   AddExperimentalTypes();
-  frontend_->OnBackendInitialized(js_backend,
-                                  debug_info_listener,
-                                  cache_guid,
+  frontend_->OnBackendInitialized(js_backend, debug_info_listener, cache_guid,
                                   true);
 }
 
 void SyncBackendHostImpl::HandleInitializationFailureOnFrontendLoop() {
   DCHECK(frontend_task_runner_->BelongsToCurrentThread());
   if (!frontend_)
     return;
 
   frontend_->OnBackendInitialized(
       syncer::WeakHandle<syncer::JsBackend>(),
-      syncer::WeakHandle<syncer::DataTypeDebugInfoListener>(),
-      "",
-      false);
+      syncer::WeakHandle<syncer::DataTypeDebugInfoListener>(), "", false);
 }
 
 void SyncBackendHostImpl::HandleSyncCycleCompletedOnFrontendLoop(
     const syncer::sessions::SyncSessionSnapshot& snapshot) {
   if (!frontend_)
     return;
   DCHECK(frontend_task_runner_->BelongsToCurrentThread());
 
   last_snapshot_ = snapshot;
 
@@ skipping 98 matching lines @@
   frontend_->OnPassphraseAccepted();
 }
 
 void SyncBackendHostImpl::NotifyEncryptedTypesChanged(
     syncer::ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   if (!frontend_)
     return;
 
   DCHECK(frontend_task_runner_->BelongsToCurrentThread());
-  frontend_->OnEncryptedTypesChanged(
-      encrypted_types, encrypt_everything);
+  frontend_->OnEncryptedTypesChanged(encrypted_types, encrypt_everything);
 }
 
 void SyncBackendHostImpl::NotifyEncryptionComplete() {
   if (!frontend_)
     return;
 
   DCHECK(frontend_task_runner_->BelongsToCurrentThread());
   frontend_->OnEncryptionComplete();
 }
 
@@ skipping 94 matching lines @@
     const syncer::SyncManager::ClearServerDataCallback& frontend_callback) {
   DCHECK(ui_thread_->BelongsToCurrentThread());
   frontend_callback.Run();
 }
 
 }  // namespace browser_sync
 
 #undef SDVLOG
 
 #undef SLOG