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

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 "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/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/core/http_post_provider_factory.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/driver/glue/sync_backend_registrar.h"
+#include "components/sync/driver/invalidation_adapter.h"
+#include "components/sync/driver/local_device_info_provider_impl.h"
 #include "components/sync/engine/events/protocol_event.h"
 #include "components/sync/sessions/commit_counters.h"
 #include "components/sync/sessions/status_counters.h"
 #include "components/sync/sessions/sync_session_snapshot.h"
 #include "components/sync/sessions/update_counters.h"
-#include "components/sync_driver/glue/sync_backend_registrar.h"
-#include "components/sync_driver/invalidation_adapter.h"
-#include "components/sync_driver/local_device_info_provider_impl.h"
 #include "url/gurl.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;
@@ skipping 90 matching lines @@
 SyncBackendHostCore::~SyncBackendHostCore() {
   DCHECK(!sync_manager_.get());
 }
 
 void SyncBackendHostCore::OnSyncCycleCompleted(
     const syncer::sessions::SyncSessionSnapshot& snapshot) {
   if (!sync_loop_)
     return;
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
 
-  host_.Call(
-      FROM_HERE,
-      &SyncBackendHostImpl::HandleSyncCycleCompletedOnFrontendLoop,
-      snapshot);
+  host_.Call(FROM_HERE,
+             &SyncBackendHostImpl::HandleSyncCycleCompletedOnFrontendLoop,
+             snapshot);
 }
 
 void SyncBackendHostCore::DoRefreshTypes(syncer::ModelTypeSet types) {
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   sync_manager_->RefreshTypes(types);
 }
 
 void SyncBackendHostCore::OnInitializationComplete(
     const syncer::WeakHandle<syncer::JsBackend>& js_backend,
     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
@@ skipping 28 matching lines @@
 
   // Before proceeding any further, we need to download the control types and
   // purge any partial data (ie. data downloaded for a type that was on its way
   // to being initially synced, but didn't quite make it.).  The following
   // configure cycle will take care of this.  It depends on the registrar state
   // which we initialize below to ensure that we don't perform any downloads if
   // all control types have already completed their initial sync.
   registrar_->SetInitialTypes(restored_types);
 
   syncer::ConfigureReason reason =
-      restored_types.Empty() ?
-       syncer::CONFIGURE_REASON_NEW_CLIENT :
-       syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE;
+      restored_types.Empty() ? syncer::CONFIGURE_REASON_NEW_CLIENT
+                             : syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE;
 
   syncer::ModelTypeSet new_control_types = registrar_->ConfigureDataTypes(
       syncer::ControlTypes(), syncer::ModelTypeSet());
   syncer::ModelSafeRoutingInfo routing_info;
   registrar_->GetModelSafeRoutingInfo(&routing_info);
   SDVLOG(1) << "Control Types "
             << syncer::ModelTypeSetToString(new_control_types)
             << " added; calling ConfigureSyncer";
 
-  syncer::ModelTypeSet types_to_purge =
-      syncer::Difference(syncer::ModelTypeSet::All(),
-                         GetRoutingInfoTypes(routing_info));
+  syncer::ModelTypeSet types_to_purge = syncer::Difference(
+      syncer::ModelTypeSet::All(), GetRoutingInfoTypes(routing_info));
 
   sync_manager_->ConfigureSyncer(
-      reason,
-      new_control_types,
-      types_to_purge,
-      syncer::ModelTypeSet(),
-      syncer::ModelTypeSet(),
-      routing_info,
+      reason, new_control_types, types_to_purge, syncer::ModelTypeSet(),
+      syncer::ModelTypeSet(), routing_info,
       base::Bind(&SyncBackendHostCore::DoInitialProcessControlTypes,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Closure());
 }
 
 void SyncBackendHostCore::OnConnectionStatusChange(
     syncer::ConnectionStatus status) {
   if (!sync_loop_)
     return;
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
-  host_.Call(
-      FROM_HERE,
-      &SyncBackendHostImpl::HandleConnectionStatusChangeOnFrontendLoop, status);
+  host_.Call(FROM_HERE,
+             &SyncBackendHostImpl::HandleConnectionStatusChangeOnFrontendLoop,
+             status);
 }
 
 void SyncBackendHostCore::OnPassphraseRequired(
     syncer::PassphraseRequiredReason reason,
     const sync_pb::EncryptedData& pending_keys) {
   if (!sync_loop_)
     return;
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
-  host_.Call(
-      FROM_HERE,
-      &SyncBackendHostImpl::NotifyPassphraseRequired, reason, pending_keys);
+  host_.Call(FROM_HERE, &SyncBackendHostImpl::NotifyPassphraseRequired, reason,
+             pending_keys);
 }
 
 void SyncBackendHostCore::OnPassphraseAccepted() {
   if (!sync_loop_)
     return;
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
-  host_.Call(
-      FROM_HERE,
-      &SyncBackendHostImpl::NotifyPassphraseAccepted);
+  host_.Call(FROM_HERE, &SyncBackendHostImpl::NotifyPassphraseAccepted);
 }
 
 void SyncBackendHostCore::OnBootstrapTokenUpdated(
     const std::string& bootstrap_token,
     syncer::BootstrapTokenType type) {
   if (!sync_loop_)
     return;
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
-  host_.Call(FROM_HERE,
-             &SyncBackendHostImpl::PersistEncryptionBootstrapToken,
-             bootstrap_token,
-             type);
+  host_.Call(FROM_HERE, &SyncBackendHostImpl::PersistEncryptionBootstrapToken,
+             bootstrap_token, type);
 }
 
 void SyncBackendHostCore::OnEncryptedTypesChanged(
     syncer::ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   if (!sync_loop_)
     return;
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   // NOTE: We're in a transaction.
-  host_.Call(
-      FROM_HERE,
-      &SyncBackendHostImpl::NotifyEncryptedTypesChanged,
-      encrypted_types, encrypt_everything);
+  host_.Call(FROM_HERE, &SyncBackendHostImpl::NotifyEncryptedTypesChanged,
+             encrypted_types, encrypt_everything);
 }
 
 void SyncBackendHostCore::OnEncryptionComplete() {
   if (!sync_loop_)
     return;
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   // NOTE: We're in a transaction.
-  host_.Call(
-      FROM_HERE,
-      &SyncBackendHostImpl::NotifyEncryptionComplete);
+  host_.Call(FROM_HERE, &SyncBackendHostImpl::NotifyEncryptionComplete);
 }
 
 void SyncBackendHostCore::OnCryptographerStateChanged(
     syncer::Cryptographer* cryptographer) {
   // Do nothing.
 }
 
-void SyncBackendHostCore::OnPassphraseTypeChanged(
-    syncer::PassphraseType type, base::Time passphrase_time) {
-  host_.Call(
-      FROM_HERE,
-      &SyncBackendHostImpl::HandlePassphraseTypeChangedOnFrontendLoop,
-      type, passphrase_time);
+void SyncBackendHostCore::OnPassphraseTypeChanged(syncer::PassphraseType type,
+                                                  base::Time passphrase_time) {
+  host_.Call(FROM_HERE,
+             &SyncBackendHostImpl::HandlePassphraseTypeChangedOnFrontendLoop,
+             type, passphrase_time);
 }
 
 void SyncBackendHostCore::OnLocalSetPassphraseEncryption(
     const syncer::SyncEncryptionHandler::NigoriState& nigori_state) {
   host_.Call(
       FROM_HERE,
       &SyncBackendHostImpl::HandleLocalSetPassphraseEncryptionOnFrontendLoop,
       nigori_state);
 }
 
@@ skipping 22 matching lines @@
       FROM_HERE,
       &SyncBackendHostImpl::HandleDirectoryStatusCountersUpdatedOnFrontendLoop,
       type, counters);
 }
 
 void SyncBackendHostCore::OnActionableError(
     const syncer::SyncProtocolError& sync_error) {
   if (!sync_loop_)
     return;
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
-  host_.Call(
-      FROM_HERE,
-      &SyncBackendHostImpl::HandleActionableErrorEventOnFrontendLoop,
-      sync_error);
+  host_.Call(FROM_HERE,
+             &SyncBackendHostImpl::HandleActionableErrorEventOnFrontendLoop,
+             sync_error);
 }
 
 void SyncBackendHostCore::OnMigrationRequested(syncer::ModelTypeSet types) {
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
-  host_.Call(
-      FROM_HERE,
-      &SyncBackendHostImpl::HandleMigrationRequestedOnFrontendLoop,
-      types);
+  host_.Call(FROM_HERE,
+             &SyncBackendHostImpl::HandleMigrationRequestedOnFrontendLoop,
+             types);
 }
 
-void SyncBackendHostCore::OnProtocolEvent(
-    const syncer::ProtocolEvent& event) {
+void SyncBackendHostCore::OnProtocolEvent(const syncer::ProtocolEvent& event) {
   // TODO(rlarocque): Find a way to pass event_clone as a scoped_ptr.
   if (forward_protocol_events_) {
     std::unique_ptr<syncer::ProtocolEvent> event_clone(event.Clone());
-    host_.Call(
-        FROM_HERE,
-        &SyncBackendHostImpl::HandleProtocolEventOnFrontendLoop,
-        event_clone.release());
+    host_.Call(FROM_HERE,
+               &SyncBackendHostImpl::HandleProtocolEventOnFrontendLoop,
+               event_clone.release());
   }
 }
 
 void SyncBackendHostCore::DoOnInvalidatorStateChange(
     syncer::InvalidatorState state) {
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   sync_manager_->SetInvalidatorEnabled(state == syncer::INVALIDATIONS_ENABLED);
 }
 
 void SyncBackendHostCore::DoOnIncomingInvalidation(
@@ skipping 22 matching lines @@
         }
         std::unique_ptr<syncer::InvalidationInterface> inv_adapter(
             new InvalidationAdapter(invalidation));
         sync_manager_->OnIncomingInvalidation(type, std::move(inv_adapter));
         if (!invalidation.is_unknown_version())
           last_invalidation_versions_[type] = invalidation.version();
       }
     }
   }
 
-  host_.Call(
-      FROM_HERE,
-      &SyncBackendHostImpl::UpdateInvalidationVersions,
-      last_invalidation_versions_);
+  host_.Call(FROM_HERE, &SyncBackendHostImpl::UpdateInvalidationVersions,
+             last_invalidation_versions_);
 }
 
 void SyncBackendHostCore::DoInitialize(
     std::unique_ptr<DoInitializeOptions> options) {
   DCHECK(!sync_loop_);
   sync_loop_ = options->sync_loop;
   DCHECK(sync_loop_);
 
   // Finish initializing the HttpBridgeFactory.  We do this here because
   // building the user agent may block on some platforms.
@@ skipping 62 matching lines @@
     const syncer::ModelSafeRoutingInfo& routing_info,
     base::Time last_poll_time) {
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   sync_manager_->StartSyncingNormally(routing_info, last_poll_time);
 }
 
 void SyncBackendHostCore::DoSetEncryptionPassphrase(
     const std::string& passphrase,
     bool is_explicit) {
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
-  sync_manager_->GetEncryptionHandler()->SetEncryptionPassphrase(
-      passphrase, is_explicit);
+  sync_manager_->GetEncryptionHandler()->SetEncryptionPassphrase(passphrase,
+                                                                 is_explicit);
 }
 
 void SyncBackendHostCore::DoInitialProcessControlTypes() {
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
 
   DVLOG(1) << "Initilalizing Control Types";
 
   // Initialize encryption.
   sync_manager_->GetEncryptionHandler()->Init();
 
   // Note: experiments are currently handled via SBH::AddExperimentalTypes,
   // which is called at the end of every sync cycle.
   // TODO(zea): eventually add an experiment handler and initialize it here.
 
   if (!sync_manager_->GetUserShare()) {  // NULL in some tests.
     DVLOG(1) << "Skipping initialization of DeviceInfo";
-    host_.Call(
-        FROM_HERE,
-        &SyncBackendHostImpl::HandleInitializationFailureOnFrontendLoop);
+    host_.Call(FROM_HERE,
+               &SyncBackendHostImpl::HandleInitializationFailureOnFrontendLoop);
     return;
   }
 
   if (!sync_manager_->InitialSyncEndedTypes().HasAll(syncer::ControlTypes())) {
     LOG(ERROR) << "Failed to download control types";
-    host_.Call(
-        FROM_HERE,
-        &SyncBackendHostImpl::HandleInitializationFailureOnFrontendLoop);
+    host_.Call(FROM_HERE,
+               &SyncBackendHostImpl::HandleInitializationFailureOnFrontendLoop);
     return;
   }
 
   host_.Call(FROM_HERE,
              &SyncBackendHostImpl::HandleInitializationSuccessOnFrontendLoop,
              js_backend_, debug_info_listener_,
              base::Passed(sync_manager_->GetModelTypeConnectorProxy()),
              sync_manager_->cache_guid());
 
   js_backend_.Reset();
   debug_info_listener_.Reset();
 }
 
 void SyncBackendHostCore::DoSetDecryptionPassphrase(
     const std::string& passphrase) {
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
-  sync_manager_->GetEncryptionHandler()->SetDecryptionPassphrase(
-      passphrase);
+  sync_manager_->GetEncryptionHandler()->SetDecryptionPassphrase(passphrase);
 }
 
 void SyncBackendHostCore::DoEnableEncryptEverything() {
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   sync_manager_->GetEncryptionHandler()->EnableEncryptEverything();
 }
 
 void SyncBackendHostCore::ShutdownOnUIThread() {
   // This will cut short any blocking network tasks, cut short any in-progress
   // sync cycles, and prevent the creation of new blocking network tasks and new
@@ skipping 37 matching lines @@
     sync_manager_->RemoveObserver(this);
     sync_manager_->ShutdownOnSyncThread(reason);
     sync_manager_.reset();
   }
 }
 
 void SyncBackendHostCore::DoConfigureSyncer(
     syncer::ConfigureReason reason,
     const DoConfigureSyncerTypes& config_types,
     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) {
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   DCHECK(!ready_task.is_null());
   DCHECK(!retry_callback.is_null());
-  base::Closure chained_ready_task(
-      base::Bind(&SyncBackendHostCore::DoFinishConfigureDataTypes,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 config_types.to_download,
-                 ready_task));
+  base::Closure chained_ready_task(base::Bind(
+      &SyncBackendHostCore::DoFinishConfigureDataTypes,
+      weak_ptr_factory_.GetWeakPtr(), config_types.to_download, ready_task));
   base::Closure chained_retry_task(
       base::Bind(&SyncBackendHostCore::DoRetryConfiguration,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 retry_callback));
-  sync_manager_->ConfigureSyncer(reason,
-                                 config_types.to_download,
-                                 config_types.to_purge,
-                                 config_types.to_journal,
-                                 config_types.to_unapply,
-                                 routing_info,
-                                 chained_ready_task,
-                                 chained_retry_task);
+                 weak_ptr_factory_.GetWeakPtr(), retry_callback));
+  sync_manager_->ConfigureSyncer(reason, config_types.to_download,
+                                 config_types.to_purge, config_types.to_journal,
+                                 config_types.to_unapply, routing_info,
+                                 chained_ready_task, chained_retry_task);
 }
 
 void SyncBackendHostCore::DoFinishConfigureDataTypes(
     syncer::ModelTypeSet types_to_config,
-    const base::Callback<void(syncer::ModelTypeSet,
-                              syncer::ModelTypeSet)>& ready_task) {
+    const base::Callback<void(syncer::ModelTypeSet, syncer::ModelTypeSet)>&
+        ready_task) {
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
 
   // Update the enabled types for the bridge and sync manager.
   syncer::ModelSafeRoutingInfo routing_info;
   registrar_->GetModelSafeRoutingInfo(&routing_info);
   syncer::ModelTypeSet enabled_types = GetRoutingInfoTypes(routing_info);
   enabled_types.RemoveAll(syncer::ProxyTypes());
 
   const syncer::ModelTypeSet failed_configuration_types =
       Difference(types_to_config, sync_manager_->InitialSyncEndedTypes());
   const syncer::ModelTypeSet succeeded_configuration_types =
       Difference(types_to_config, failed_configuration_types);
   host_.Call(FROM_HERE,
              &SyncBackendHostImpl::FinishConfigureDataTypesOnFrontendLoop,
-             enabled_types,
-             succeeded_configuration_types,
-             failed_configuration_types,
-             ready_task);
+             enabled_types, succeeded_configuration_types,
+             failed_configuration_types, ready_task);
 }
 
 void SyncBackendHostCore::DoRetryConfiguration(
     const base::Closure& retry_callback) {
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
-  host_.Call(FROM_HERE,
-             &SyncBackendHostImpl::RetryConfigurationOnFrontendLoop,
+  host_.Call(FROM_HERE, &SyncBackendHostImpl::RetryConfigurationOnFrontendLoop,
              retry_callback);
 }
 
 void SyncBackendHostCore::SendBufferedProtocolEventsAndEnableForwarding() {
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   forward_protocol_events_ = true;
 
   if (sync_manager_) {
     // Grab our own copy of the buffered events.
     // The buffer is not modified by this operation.
     std::vector<syncer::ProtocolEvent*> buffered_events;
     sync_manager_->GetBufferedProtocolEvents().release(&buffered_events);
 
     // Send them all over the fence to the host.
     for (std::vector<syncer::ProtocolEvent*>::iterator it =
-         buffered_events.begin(); it != buffered_events.end(); ++it) {
+             buffered_events.begin();
+         it != buffered_events.end(); ++it) {
       // TODO(rlarocque): Make it explicit that host_ takes ownership.
-      host_.Call(
-          FROM_HERE,
-          &SyncBackendHostImpl::HandleProtocolEventOnFrontendLoop,
-          *it);
+      host_.Call(FROM_HERE,
+                 &SyncBackendHostImpl::HandleProtocolEventOnFrontendLoop, *it);
     }
   }
 }
 
 void SyncBackendHostCore::DisableProtocolEventForwarding() {
   forward_protocol_events_ = false;
 }
 
 void SyncBackendHostCore::EnableDirectoryTypeDebugInfoForwarding() {
   DCHECK(sync_manager_);
@@ skipping 41 matching lines @@
     types_vector.push_back(it.Get());
     if (!enabled_types.Has(it.Get())) {
       node_lists.push_back(new base::ListValue());
     } else {
       node_lists.push_back(
           sync_manager_->GetAllNodesForType(it.Get()).release());
     }
   }
 
   task_runner->PostTask(
-      FROM_HERE,
-      base::Bind(callback, types_vector, base::Passed(&node_lists)));
+      FROM_HERE, base::Bind(callback, types_vector, base::Passed(&node_lists)));
 }
 
 void SyncBackendHostCore::StartSavingChanges() {
   // We may already be shut down.
   if (!sync_loop_)
     return;
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   DCHECK(!save_changes_timer_.get());
   save_changes_timer_.reset(new base::RepeatingTimer());
-  save_changes_timer_->Start(FROM_HERE,
-      base::TimeDelta::FromSeconds(kSaveChangesIntervalSeconds),
+  save_changes_timer_->Start(
+      FROM_HERE, base::TimeDelta::FromSeconds(kSaveChangesIntervalSeconds),
       this, &SyncBackendHostCore::SaveChanges);
 }
 
 void SyncBackendHostCore::SaveChanges() {
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   sync_manager_->SaveChanges();
 }
 
 void SyncBackendHostCore::DoClearServerData(
     const syncer::SyncManager::ClearServerDataCallback& frontend_callback) {
@@ skipping 10 matching lines @@
   sync_manager_->OnCookieJarChanged(account_mismatch, empty_jar);
 }
 
 void SyncBackendHostCore::ClearServerDataDone(
     const base::Closure& frontend_callback) {
   DCHECK(sync_loop_->task_runner()->BelongsToCurrentThread());
   host_.Call(FROM_HERE, &SyncBackendHostImpl::ClearServerDataDoneOnFrontendLoop,
              frontend_callback);
 }
 
-
 }  // namespace browser_sync