[Sync] SyncEngine 1.5: Fix all backend references in PSS.

components/browser_sync/profile_sync_service.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/browser_sync/profile_sync_service.h"
 
 #include <stddef.h>
 
 #include <cstddef>
 #include <map>
@@ skipping 185 matching lines @@
           syncer::GetSyncServiceURL(*base::CommandLine::ForCurrentProcess(),
                                     init_params.channel)),
       network_time_update_callback_(
           std::move(init_params.network_time_update_callback)),
       base_directory_(init_params.base_directory),
       url_request_context_(init_params.url_request_context),
       debug_identifier_(std::move(init_params.debug_identifier)),
       channel_(init_params.channel),
       blocking_pool_(init_params.blocking_pool),
       is_first_time_sync_configure_(false),
-      backend_initialized_(false),
+      engine_initialized_(false),
       sync_disabled_by_admin_(false),
       is_auth_in_progress_(false),
       signin_(std::move(init_params.signin_wrapper)),
       unrecoverable_error_reason_(ERROR_REASON_UNSET),
       expect_sync_configuration_aborted_(false),
       encrypted_types_(syncer::SyncEncryptionHandler::SensitiveTypes()),
       encrypt_everything_allowed_(true),
       encrypt_everything_(false),
       encryption_pending_(false),
       configure_status_(DataTypeManager::UNKNOWN),
@@ skipping 23 matching lines @@
     passphrase_prompt_triggered_by_version_ = true;
   }
 }
 
 ProfileSyncService::~ProfileSyncService() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (gaia_cookie_manager_service_)
     gaia_cookie_manager_service_->RemoveObserver(this);
   sync_prefs_.RemoveSyncPrefObserver(this);
   // Shutdown() should have been called before destruction.
-  CHECK(!backend_initialized_);
+  CHECK(!engine_initialized_);
 }
 
 bool ProfileSyncService::CanSyncStart() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return IsSyncAllowed() && IsSyncRequested() && IsSignedIn();
 }
 
 void ProfileSyncService::Initialize() {
   DCHECK(thread_checker_.CalledOnValidThread());
   sync_client_->Initialize();
 
   // We don't pass StartupController an Unretained reference to future-proof
   // against the controller impl changing to post tasks.
   startup_controller_ = base::MakeUnique<syncer::StartupController>(
       &sync_prefs_,
-      base::Bind(&ProfileSyncService::CanBackendStart, base::Unretained(this)),
-      base::Bind(&ProfileSyncService::StartUpSlowBackendComponents,
+      base::Bind(&ProfileSyncService::CanEngineStart, base::Unretained(this)),
+      base::Bind(&ProfileSyncService::StartUpSlowEngineComponents,
                  weak_factory_.GetWeakPtr()));
   std::unique_ptr<sync_sessions::LocalSessionEventRouter> router(
       sync_client_->GetSyncSessionsClient()->GetLocalSessionEventRouter());
   local_device_ = sync_client_->GetSyncApiComponentFactory()
                       ->CreateLocalDeviceInfoProvider();
   sync_stopped_reporter_ = base::MakeUnique<syncer::SyncStoppedReporter>(
       sync_service_url_, local_device_->GetSyncUserAgent(),
       url_request_context_, syncer::SyncStoppedReporter::ResultCallback());
   sessions_sync_manager_ = base::MakeUnique<SessionsSyncManager>(
       sync_client_->GetSyncSessionsClient(), &sync_prefs_, local_device_.get(),
@@ skipping 106 matching lines @@
 }
 
 void ProfileSyncService::StartSyncingWithServer() {
   if (base::FeatureList::IsEnabled(
           switches::kSyncClearDataOnPassphraseEncryption) &&
       sync_prefs_.GetPassphraseEncryptionTransitionInProgress()) {
     BeginConfigureCatchUpBeforeClear();
     return;
   }
 
-  if (backend_)
-    backend_->StartSyncingWithServer();
+  if (engine_)
+    engine_->StartSyncingWithServer();
 }
 
 void ProfileSyncService::RegisterAuthNotifications() {
   DCHECK(thread_checker_.CalledOnValidThread());
   oauth2_token_service_->AddObserver(this);
   if (signin())
     signin()->AddObserver(this);
 }
 
 void ProfileSyncService::UnregisterAuthNotifications() {
@@ skipping 86 matching lines @@
 
   credentials.scope_set.insert(signin_->GetSyncScopeToUse());
 
   return credentials;
 }
 
 bool ProfileSyncService::ShouldDeleteSyncFolder() {
   return !IsFirstSetupComplete();
 }
 
-void ProfileSyncService::InitializeBackend(bool delete_stale_data) {
-  if (!backend_) {
+void ProfileSyncService::InitializeEngine(bool delete_stale_data) {
+  if (!engine_) {
     NOTREACHED();
     return;
   }
 
   if (!sync_thread_) {
     sync_thread_ = base::MakeUnique<base::Thread>("Chrome_SyncThread");
     base::Thread::Options options;
     options.timer_slack = base::TIMER_SLACK_MAXIMUM;
     CHECK(sync_thread_->StartWithOptions(options));
   }
@@ skipping 26 matching lines @@
       local_sync_backend_folder.Append(base_directory_.BaseName());
   local_sync_backend_folder =
       local_sync_backend_folder.Append(kLoopbackServerBackendFilename);
 #endif  // defined(OS_WIN)
 
   SyncEngine::HttpPostProviderFactoryGetter http_post_provider_factory_getter =
       base::Bind(&syncer::NetworkResources::GetHttpPostProviderFactory,
                  base::Unretained(network_resources_.get()),
                  url_request_context_, network_time_update_callback_);
 
-  backend_->Initialize(
+  engine_->Initialize(
       this, sync_thread_->task_runner(), GetJsEventHandler(), sync_service_url_,
       local_device_->GetSyncUserAgent(), credentials, delete_stale_data,
       enable_local_sync_backend, local_sync_backend_folder,
       base::MakeUnique<syncer::SyncManagerFactory>(),
       MakeWeakHandle(sync_enabled_weak_factory_.GetWeakPtr()),
       base::Bind(syncer::ReportUnrecoverableError, channel_),
       http_post_provider_factory_getter, std::move(saved_nigori_state_));
 }
 
 bool ProfileSyncService::IsEncryptedDatatypeEnabled() const {
@@ skipping 50 matching lines @@
   // If this is a data type change after a major version update, reset the
   // passphrase prompted state and notify observers.
   if (IsPassphraseRequired() && passphrase_prompt_triggered_by_version_) {
     // The major version has changed and a local syncable change was made.
     // Reset the passphrase prompt state.
     passphrase_prompt_triggered_by_version_ = false;
     sync_prefs_.SetPassphrasePrompted(false);
     NotifyObservers();
   }
 
-  if (backend_.get()) {
+  if (engine_) {
     DVLOG(1) << "A data type requested sync startup, but it looks like "
                 "something else beat it to the punch.";
     return;
   }
 
   startup_controller_->OnDataTypeRequestsSyncStartup(type);
 }
 
-void ProfileSyncService::StartUpSlowBackendComponents() {
+void ProfileSyncService::StartUpSlowEngineComponents() {
   invalidation::InvalidationService* invalidator =
       sync_client_->GetInvalidationService();
 
-  backend_.reset(sync_client_->GetSyncApiComponentFactory()->CreateSyncEngine(
+  engine_.reset(sync_client_->GetSyncApiComponentFactory()->CreateSyncEngine(
       debug_identifier_, invalidator, sync_prefs_.AsWeakPtr(),
       directory_path_));
 
-  // Initialize the backend. Every time we start up a new SyncEngine, we'll want
+  // Initialize the engine. Every time we start up a new SyncEngine, we'll want
   // to start from a fresh SyncDB, so delete any old one that might be there.
-  InitializeBackend(ShouldDeleteSyncFolder());
+  InitializeEngine(ShouldDeleteSyncFolder());
 
   UpdateFirstSyncTimePref();
 
   ReportPreviousSessionMemoryWarningCount();
 }
 
 void ProfileSyncService::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const base::Time& expiration_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(access_token_request_.get(), request);
   access_token_request_.reset();
   access_token_ = access_token;
   token_receive_time_ = base::Time::Now();
   last_get_token_error_ = GoogleServiceAuthError::AuthErrorNone();
 
   if (sync_prefs_.SyncHasAuthError()) {
     sync_prefs_.SetSyncAuthError(false);
   }
 
-  if (HasSyncingBackend())
-    backend_->UpdateCredentials(GetCredentials());
+  if (HasSyncingEngine())
+    engine_->UpdateCredentials(GetCredentials());
   else
     startup_controller_->TryStart();
 }
 
 void ProfileSyncService::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(access_token_request_.get(), request);
   DCHECK_NE(error.state(), GoogleServiceAuthError::NONE);
@@ skipping 51 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   if (account_id == signin_->GetAccountIdToUse()) {
     access_token_.clear();
     UpdateAuthErrorState(
         GoogleServiceAuthError(GoogleServiceAuthError::REQUEST_CANCELED));
   }
 }
 
 void ProfileSyncService::OnRefreshTokensLoaded() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  // This notification gets fired when OAuth2TokenService loads the tokens
-  // from storage.
-  // Initialize the backend if sync is enabled. If the sync token was
-  // not loaded, GetCredentials() will generate invalid credentials to
-  // cause the backend to generate an auth error (crbug.com/121755).
-  if (HasSyncingBackend()) {
+  // This notification gets fired when OAuth2TokenService loads the tokens from
+  // storage. Initialize the engine if sync is enabled. If the sync token was
+  // not loaded, GetCredentials() will generate invalid credentials to cause the
+  // engine to generate an auth error (crbug.com/121755).
+  if (HasSyncingEngine()) {
     RequestAccessToken();
   } else {
     startup_controller_->TryStart();
   }
 }
 
 void ProfileSyncService::Shutdown() {
   DCHECK(thread_checker_.CalledOnValidThread());
   UnregisterAuthNotifications();
 
   ShutdownImpl(syncer::BROWSER_SHUTDOWN);
   if (sync_error_controller_) {
     // Destroy the SyncErrorController when the service shuts down for good.
     RemoveObserver(sync_error_controller_.get());
     sync_error_controller_.reset();
   }
 
   if (sync_thread_)
     sync_thread_->Stop();
 }
 
 void ProfileSyncService::ShutdownImpl(syncer::ShutdownReason reason) {
-  if (!backend_) {
+  if (!engine_) {
     if (reason == syncer::ShutdownReason::DISABLE_SYNC && sync_thread_) {
-      // If the backend is already shut down when a DISABLE_SYNC happens,
+      // If the engine is already shut down when a DISABLE_SYNC happens,
       // the data directory needs to be cleaned up here.
       sync_thread_->task_runner()->PostTask(
           FROM_HERE, base::Bind(&DeleteSyncDataFolder, directory_path_));
     }
     return;
   }
 
   if (reason == syncer::ShutdownReason::STOP_SYNC ||
       reason == syncer::ShutdownReason::DISABLE_SYNC) {
     RemoveClientFromServer();
   }
 
-  // First, we spin down the backend to stop change processing as soon as
+  // First, we spin down the engine to stop change processing as soon as
   // possible.
   base::Time shutdown_start_time = base::Time::Now();
-  backend_->StopSyncingForShutdown();
+  engine_->StopSyncingForShutdown();
 
-  // Stop all data type controllers, if needed.  Note that until Stop
-  // completes, it is possible in theory to have a ChangeProcessor apply a
-  // change from a native model.  In that case, it will get applied to the sync
-  // database (which doesn't get destroyed until we destroy the backend below)
-  // as an unsynced change.  That will be persisted, and committed on restart.
+  // Stop all data type controllers, if needed. Note that until Stop completes,
+  // it is possible in theory to have a ChangeProcessor apply a change from a
+  // native model. In that case, it will get applied to the sync database (which
+  // doesn't get destroyed until we destroy the engine below) as an unsynced
+  // change. That will be persisted, and committed on restart.
   if (data_type_manager_) {
     if (data_type_manager_->state() != DataTypeManager::STOPPED) {
       // When aborting as part of shutdown, we should expect an aborted sync
       // configure result, else we'll dcheck when we try to read the sync error.
       expect_sync_configuration_aborted_ = true;
       data_type_manager_->Stop();
     }
     data_type_manager_.reset();
   }
 
-  // Shutdown the migrator before the backend to ensure it doesn't pull a null
+  // Shutdown the migrator before the engine to ensure it doesn't pull a null
   // snapshot.
   migrator_.reset();
   sync_js_controller_.AttachJsBackend(WeakHandle<syncer::JsBackend>());
 
-  backend_->Shutdown(reason);
-  backend_.reset();
+  engine_->Shutdown(reason);
+  engine_.reset();
 
   base::TimeDelta shutdown_time = base::Time::Now() - shutdown_start_time;
   UMA_HISTOGRAM_TIMES("Sync.Shutdown.BackendDestroyedTime", shutdown_time);
 
   sync_enabled_weak_factory_.InvalidateWeakPtrs();
 
   startup_controller_->Reset(GetRegisteredDataTypes());
 
   // If the sync DB is getting destroyed, the local DeviceInfo is no longer
   // valid and should be cleared from the cache.
   if (reason == syncer::ShutdownReason::DISABLE_SYNC) {
     local_device_->Clear();
   }
 
   // Clear various flags.
   expect_sync_configuration_aborted_ = false;
   is_auth_in_progress_ = false;
-  backend_initialized_ = false;
+  engine_initialized_ = false;
   cached_passphrase_.clear();
   encryption_pending_ = false;
   encrypt_everything_ = false;
   encrypted_types_ = syncer::SyncEncryptionHandler::SensitiveTypes();
   passphrase_required_reason_ = syncer::REASON_PASSPHRASE_NOT_REQUIRED;
   catch_up_configure_in_progress_ = false;
   access_token_.clear();
   request_access_token_retry_timer_.Stop();
   // Revert to "no auth error".
   if (last_auth_error_.state() != GoogleServiceAuthError::NONE)
     UpdateAuthErrorState(GoogleServiceAuthError::AuthErrorNone());
 
   NotifyObservers();
 
   // Mark this as a clean shutdown(without crash).
   sync_prefs_.SetCleanShutdown(true);
 }
 
 void ProfileSyncService::StopImpl(SyncStopDataFate data_fate) {
   switch (data_fate) {
     case KEEP_DATA:
       // TODO(maxbogue): Investigate whether this logic can/should be moved
       // into ShutdownImpl or the sync engine itself.
-      if (HasSyncingBackend()) {
-        backend_->UnregisterInvalidationIds();
+      if (HasSyncingEngine()) {
+        engine_->UnregisterInvalidationIds();
       }
       ShutdownImpl(syncer::STOP_SYNC);
       break;
     case CLEAR_DATA:
       // Clear prefs (including SyncSetupHasCompleted) before shutting down so
       // PSS clients don't think we're set up while we're shutting down.
       sync_prefs_.ClearPreferences();
       ClearUnrecoverableError();
       ShutdownImpl(syncer::DISABLE_SYNC);
       break;
   }
 }
 
 bool ProfileSyncService::IsFirstSetupComplete() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return sync_prefs_.IsFirstSetupComplete();
 }
 
 void ProfileSyncService::SetFirstSetupComplete() {
   DCHECK(thread_checker_.CalledOnValidThread());
   sync_prefs_.SetFirstSetupComplete();
-  if (IsBackendInitialized()) {
+  if (IsEngineInitialized()) {
     ReconfigureDatatypeManager();
   }
 }
 
 void ProfileSyncService::UpdateLastSyncedTime() {
   sync_prefs_.SetLastSyncedTime(base::Time::Now());
 }
 
 void ProfileSyncService::NotifyObservers() {
   for (auto& observer : observers_)
@@ skipping 54 matching lines @@
   // Shut all data types down.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&ProfileSyncService::ShutdownImpl,
                             sync_enabled_weak_factory_.GetWeakPtr(),
                             delete_sync_database ? syncer::DISABLE_SYNC
                                                  : syncer::STOP_SYNC));
 }
 
 void ProfileSyncService::ReenableDatatype(syncer::ModelType type) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!backend_initialized_ || !data_type_manager_)
+  if (!engine_initialized_ || !data_type_manager_)
     return;
   data_type_manager_->ReenableType(type);
 }
 
-void ProfileSyncService::UpdateBackendInitUMA(bool success) {
+void ProfileSyncService::UpdateEngineInitUMA(bool success) {
   is_first_time_sync_configure_ = !IsFirstSetupComplete();
 
   if (is_first_time_sync_configure_) {
     UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeFirstTimeSuccess", success);
   } else {
     UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeRestoreSuccess", success);
   }
 
-  base::Time on_backend_initialized_time = base::Time::Now();
+  base::Time on_engine_initialized_time = base::Time::Now();
   base::TimeDelta delta =
-      on_backend_initialized_time - startup_controller_->start_engine_time();
+      on_engine_initialized_time - startup_controller_->start_engine_time();
   if (is_first_time_sync_configure_) {
     UMA_HISTOGRAM_LONG_TIMES("Sync.BackendInitializeFirstTime", delta);
   } else {
     UMA_HISTOGRAM_LONG_TIMES("Sync.BackendInitializeRestoreTime", delta);
   }
 }
 
-void ProfileSyncService::PostBackendInitialization() {
+void ProfileSyncService::PostEngineInitialization() {
   if (protocol_event_observers_.might_have_observers()) {
-    backend_->RequestBufferedProtocolEventsAndEnableForwarding();
+    engine_->RequestBufferedProtocolEventsAndEnableForwarding();
   }
 
   if (type_debug_info_observers_.might_have_observers()) {
-    backend_->EnableDirectoryTypeDebugInfoForwarding();
+    engine_->EnableDirectoryTypeDebugInfoForwarding();
   }
 
   // If we have a cached passphrase use it to decrypt/encrypt data now that the
-  // backend is initialized. We want to call this before notifying observers in
+  // engine is initialized. We want to call this before notifying observers in
   // case this operation affects the "passphrase required" status.
   ConsumeCachedPassphraseIfPossible();
 
-  // The very first time the backend initializes is effectively the first time
+  // The very first time the engine initializes is effectively the first time
   // we can say we successfully "synced".  LastSyncedTime will only be null in
   // this case, because the pref wasn't restored on StartUp.
   if (sync_prefs_.GetLastSyncedTime().is_null()) {
     UpdateLastSyncedTime();
   }
 
   // Auto-start means IsFirstSetupComplete gets set automatically.
   if (start_behavior_ == AUTO_START && !IsFirstSetupComplete()) {
     // This will trigger a configure if it completes setup.
     SetFirstSetupComplete();
   } else if (CanConfigureDataTypes()) {
     ConfigureDataTypeManager();
   }
 
   // Check for a cookie jar mismatch.
   std::vector<gaia::ListedAccount> accounts;
   std::vector<gaia::ListedAccount> signed_out_accounts;
   GoogleServiceAuthError error(GoogleServiceAuthError::NONE);
   if (gaia_cookie_manager_service_ &&
       gaia_cookie_manager_service_->ListAccounts(
           &accounts, &signed_out_accounts, "ChromiumProfileSyncService")) {
     OnGaiaAccountsInCookieUpdated(accounts, signed_out_accounts, error);
   }
 
   NotifyObservers();
 }
 
-void ProfileSyncService::OnBackendInitialized(
+void ProfileSyncService::OnEngineInitialized(
     const syncer::WeakHandle<syncer::JsBackend>& js_backend,
     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
         debug_info_listener,
     const std::string& cache_guid,
     bool success) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  UpdateBackendInitUMA(success);
+  UpdateEngineInitUMA(success);
 
   if (!success) {
     // Something went unexpectedly wrong.  Play it safe: stop syncing at once
     // and surface error UI to alert the user sync has stopped.
     // Keep the directory around for now so that on restart we will retry
     // again and potentially succeed in presence of transient file IO failures
     // or permissions issues, etc.
     //
     // TODO(rlarocque): Consider making this UnrecoverableError less special.
     // Unlike every other UnrecoverableError, it does not delete our sync data.
     // This exception made sense at the time it was implemented, but our new
     // directory corruption recovery mechanism makes it obsolete.  By the time
     // we get here, we will have already tried and failed to delete the
     // directory.  It would be no big deal if we tried to delete it again.
     OnInternalUnrecoverableError(FROM_HERE, "BackendInitialize failure", false,
-                                 ERROR_REASON_BACKEND_INIT_FAILURE);
+                                 ERROR_REASON_ENGINE_INIT_FAILURE);
     return;
   }
 
-  backend_initialized_ = true;
+  engine_initialized_ = true;
 
   sync_js_controller_.AttachJsBackend(js_backend);
   debug_info_listener_ = debug_info_listener;
 
   SigninClient* signin_client = signin_->GetOriginal()->signin_client();
   DCHECK(signin_client);
   std::string signin_scoped_device_id =
       signin_client->GetSigninScopedDeviceId();
 
   // Initialize local device info.
   local_device_->Initialize(cache_guid, signin_scoped_device_id,
                             blocking_pool_);
 
-  PostBackendInitialization();
+  PostEngineInitialization();
 }
 
 void ProfileSyncService::OnSyncCycleCompleted() {
   DCHECK(thread_checker_.CalledOnValidThread());
   UpdateLastSyncedTime();
   const syncer::SyncCycleSnapshot snapshot = GetLastCycleSnapshot();
   if (IsDataTypeControllerRunning(syncer::SESSIONS) &&
       snapshot.model_neutral_state().get_updates_request_types.Has(
           syncer::SESSIONS) &&
       !syncer::HasSyncerError(snapshot.model_neutral_state())) {
@@ skipping 70 matching lines @@
     // attempting a token/sync request in between, thus crank up request delay
     // unnecessary. This is because we won't make a sync request if we hit an
     // error until GAIA succeeds at sending a new token, and we won't request
     // a new token unless sync reports a token failure. But to be safe, don't
     // schedule request if this happens.
     if (request_access_token_retry_timer_.IsRunning()) {
       // The timer to perform a request later is already running; nothing
       // further needs to be done at this point.
     } else if (request_access_token_backoff_.failure_count() == 0) {
       // First time request without delay. Currently invalid token is used
-      // to initialize sync backend and we'll always end up here. We don't
+      // to initialize sync engine and we'll always end up here. We don't
       // want to delay initialization.
       request_access_token_backoff_.InformOfRequest(false);
       RequestAccessToken();
     } else {
       request_access_token_backoff_.InformOfRequest(false);
       request_access_token_retry_timer_.Start(
           FROM_HERE, request_access_token_backoff_.GetTimeUntilRelease(),
           base::Bind(&ProfileSyncService::RequestAccessToken,
                      sync_enabled_weak_factory_.GetWeakPtr()));
     }
@@ skipping 13 matching lines @@
         ConnectionStatusToAuthError(status);
     DVLOG(1) << "Connection status change: " << auth_error.ToString();
     UpdateAuthErrorState(auth_error);
   }
 }
 
 void ProfileSyncService::OnPassphraseRequired(
     syncer::PassphraseRequiredReason reason,
     const sync_pb::EncryptedData& pending_keys) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(backend_.get());
-  DCHECK(backend_->IsNigoriEnabled());
+  DCHECK(engine_);
+  DCHECK(engine_->IsNigoriEnabled());
 
   // TODO(lipalani) : add this check to other locations as well.
   if (HasUnrecoverableError()) {
     // When unrecoverable error is detected we post a task to shutdown the
-    // backend. The task might not have executed yet.
+    // engine. The task might not have executed yet.
     return;
   }
 
   DVLOG(1) << "Passphrase required with reason: "
            << syncer::PassphraseRequiredReasonToString(reason);
   passphrase_required_reason_ = reason;
 
   const syncer::ModelTypeSet types = GetPreferredDataTypes();
   if (data_type_manager_) {
     // Reconfigure without the encrypted types (excluded implicitly via the
@@ skipping 51 matching lines @@
   if (encryption_pending_ && encrypt_everything_) {
     encryption_pending_ = false;
     // This is to nudge the integration tests when encryption is
     // finished.
     NotifyObservers();
   }
 }
 
 void ProfileSyncService::OnMigrationNeededForTypes(syncer::ModelTypeSet types) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(backend_initialized_);
-  DCHECK(data_type_manager_.get());
+  DCHECK(engine_initialized_);
+  DCHECK(data_type_manager_);
 
   // Migrator must be valid, because we don't sync until it is created and this
   // callback originates from a sync cycle.
   migrator_->MigrateTypes(types);
 }
 
 void ProfileSyncService::OnActionableError(const SyncProtocolError& error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   last_actionable_error_ = error;
   DCHECK_NE(last_actionable_error_.action, syncer::UNKNOWN_ACTION);
@@ skipping 66 matching lines @@
   saved_nigori_state_ =
       base::MakeUnique<syncer::SyncEncryptionHandler::NigoriState>();
   sync_prefs_.GetNigoriSpecificsForPassphraseTransition(
       &saved_nigori_state_->nigori_specifics);
   const syncer::ModelTypeSet types = GetActiveDataTypes();
   catch_up_configure_in_progress_ = true;
   data_type_manager_->Configure(types, syncer::CONFIGURE_REASON_CATCH_UP);
 }
 
 void ProfileSyncService::ClearAndRestartSyncForPassphraseEncryption() {
-  backend_->ClearServerData(
+  DCHECK(thread_checker_.CalledOnValidThread());
+  engine_->ClearServerData(
       base::Bind(&ProfileSyncService::OnClearServerDataDone,
                  sync_enabled_weak_factory_.GetWeakPtr()));
 }
 
 void ProfileSyncService::OnClearServerDataDone() {
   DCHECK(sync_prefs_.GetPassphraseEncryptionTransitionInProgress());
   sync_prefs_.SetPassphraseEncryptionTransitionInProgress(false);
 
   // Call to ClearServerData generates new keystore key on the server. This
   // makes keystore bootstrap token invalid. Let's clear it from preferences.
   sync_prefs_.SetKeystoreEncryptionBootstrapToken(std::string());
 
   // Shutdown sync, delete the Directory, then restart, restoring the cached
   // nigori state.
   ShutdownImpl(syncer::DISABLE_SYNC);
   startup_controller_->TryStart();
 }
 
 void ProfileSyncService::OnConfigureDone(
     const DataTypeManager::ConfigureResult& result) {
   DCHECK(thread_checker_.CalledOnValidThread());
   configure_status_ = result.status;
   data_type_status_table_ = result.data_type_status_table;
 
   // We should have cleared our cached passphrase before we get here (in
-  // OnBackendInitialized()).
+  // OnEngineInitialized()).
   DCHECK(cached_passphrase_.empty());
 
   if (!sync_configure_start_time_.is_null()) {
     if (result.status == DataTypeManager::OK) {
       base::Time sync_configure_stop_time = base::Time::Now();
       base::TimeDelta delta =
           sync_configure_stop_time - sync_configure_start_time_;
       if (is_first_time_sync_configure_) {
         UMA_HISTOGRAM_LONG_TIMES("Sync.ServiceInitialConfigureTime", delta);
       } else {
@@ skipping 44 matching lines @@
   DCHECK_EQ(DataTypeManager::OK, configure_status_);
 
   // We should never get in a state where we have no encrypted datatypes
   // enabled, and yet we still think we require a passphrase for decryption.
   DCHECK(
       !(IsPassphraseRequiredForDecryption() && !IsEncryptedDatatypeEnabled()));
 
   // This must be done before we start syncing with the server to avoid
   // sending unencrypted data up on a first time sync.
   if (encryption_pending_)
-    backend_->EnableEncryptEverything();
+    engine_->EnableEncryptEverything();
   NotifyObservers();
 
   if (migrator_.get() && migrator_->state() != BackendMigrator::IDLE) {
     // Migration in progress.  Let the migrator know we just finished
     // configuring something.  It will be up to the migrator to call
     // StartSyncingWithServer() if migration is now finished.
     migrator_->OnConfigureDone(result);
     return;
   }
 
@@ skipping 10 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   sync_configure_start_time_ = base::Time::Now();
   NotifyObservers();
 }
 
 ProfileSyncService::SyncStatusSummary
 ProfileSyncService::QuerySyncStatusSummary() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (HasUnrecoverableError()) {
     return UNRECOVERABLE_ERROR;
-  } else if (!backend_) {
+  } else if (!engine_) {
     return NOT_ENABLED;
-  } else if (backend_.get() && !IsFirstSetupComplete()) {
+  } else if (engine_ && !IsFirstSetupComplete()) {
     return SETUP_INCOMPLETE;
-  } else if (backend_ && IsFirstSetupComplete() && data_type_manager_ &&
+  } else if (engine_ && IsFirstSetupComplete() && data_type_manager_ &&
              data_type_manager_->state() == DataTypeManager::STOPPED) {
     return DATATYPES_NOT_INITIALIZED;
   } else if (IsSyncActive()) {
     return INITIALIZED;
   }
   return UNKNOWN_ERROR;
 }
 
 std::string ProfileSyncService::QuerySyncStatusSummaryString() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 13 matching lines @@
       return "First time sync setup incomplete";
     case DATATYPES_NOT_INITIALIZED:
       return "Datatypes not fully initialized";
     case INITIALIZED:
       return "Sync service initialized";
     default:
       return "Status unknown: Internal error?";
   }
 }
 
-std::string ProfileSyncService::GetBackendInitializationStateString() const {
+std::string ProfileSyncService::GetEngineInitializationStateString() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return startup_controller_->GetEngineInitializationStateString();
 }
 
 bool ProfileSyncService::IsSetupInProgress() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return startup_controller_->IsSetupInProgress();
 }
 
 bool ProfileSyncService::QueryDetailedSyncStatus(SyncEngine::Status* result) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (backend_.get() && backend_initialized_) {
-    *result = backend_->GetDetailedStatus();
+  if (engine_ && engine_initialized_) {
+    *result = engine_->GetDetailedStatus();
     return true;
   } else {
     SyncEngine::Status status;
     status.sync_protocol_error = last_actionable_error_;
     *result = status;
     return false;
   }
 }
 
 const AuthError& ProfileSyncService::GetAuthError() const {
@@ skipping 26 matching lines @@
                      weak_factory_.GetWeakPtr())));
 }
 
 bool ProfileSyncService::IsSyncAllowed() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return IsSyncAllowedByFlag() && !IsManaged() && IsSyncAllowedByPlatform();
 }
 
 bool ProfileSyncService::IsSyncActive() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return backend_initialized_ && data_type_manager_ &&
+  return engine_initialized_ && data_type_manager_ &&
          data_type_manager_->state() != DataTypeManager::STOPPED;
 }
 
 void ProfileSyncService::TriggerRefresh(const syncer::ModelTypeSet& types) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (backend_initialized_)
-    backend_->TriggerRefresh(types);
+  if (engine_initialized_)
+    engine_->TriggerRefresh(types);
 }
 
 bool ProfileSyncService::IsSignedIn() const {
   // Sync is logged in if there is a non-empty effective account id.
   return !signin_->GetAccountIdToUse().empty();
 }
 
-bool ProfileSyncService::CanBackendStart() const {
+bool ProfileSyncService::CanEngineStart() const {
   return CanSyncStart() && oauth2_token_service_ &&
          oauth2_token_service_->RefreshTokenIsAvailable(
              signin_->GetAccountIdToUse());
 }
 
-bool ProfileSyncService::IsBackendInitialized() const {
+bool ProfileSyncService::IsEngineInitialized() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return backend_initialized_;
+  return engine_initialized_;
 }
 
 bool ProfileSyncService::ConfigurationDone() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return data_type_manager_ &&
          data_type_manager_->state() == DataTypeManager::CONFIGURED;
 }
 
 bool ProfileSyncService::waiting_for_auth() const {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 104 matching lines @@
   sync_prefs_.SetSpareBootstrapToken(bootstrap_token);
 }
 #endif
 
 void ProfileSyncService::OnUserChoseDatatypes(
     bool sync_everything,
     syncer::ModelTypeSet chosen_types) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(syncer::UserSelectableTypes().HasAll(chosen_types));
 
-  if (!backend_.get() && !HasUnrecoverableError()) {
+  if (!engine_ && !HasUnrecoverableError()) {
     NOTREACHED();
     return;
   }
 
   UpdateSelectedTypesHistogram(sync_everything, chosen_types);
   sync_prefs_.SetKeepEverythingSynced(sync_everything);
 
   if (data_type_manager_)
     data_type_manager_->ResetDataTypeErrors();
   ChangePreferredDataTypes(chosen_types);
@@ skipping 69 matching lines @@
 std::string ProfileSyncService::GetCustomPassphraseKey() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   syncer::SystemEncryptor encryptor;
   syncer::Cryptographer cryptographer(&encryptor);
   cryptographer.Bootstrap(sync_prefs_.GetEncryptionBootstrapToken());
   return cryptographer.GetDefaultNigoriKeyData();
 }
 
 syncer::PassphraseType ProfileSyncService::GetPassphraseType() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return backend_->GetPassphraseType();
+  return engine_->GetPassphraseType();
 }
 
 base::Time ProfileSyncService::GetExplicitPassphraseTime() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return backend_->GetExplicitPassphraseTime();
+  return engine_->GetExplicitPassphraseTime();
 }
 
 bool ProfileSyncService::IsCryptographerReady(
     const syncer::BaseTransaction* trans) const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return backend_.get() && backend_->IsCryptographerReady(trans);
+  return engine_ && engine_->IsCryptographerReady(trans);
 }
 
 void ProfileSyncService::SetPlatformSyncAllowedProvider(
     const PlatformSyncAllowedProvider& platform_sync_allowed_provider) {
   DCHECK(thread_checker_.CalledOnValidThread());
   platform_sync_allowed_provider_ = platform_sync_allowed_provider;
 }
 
 void ProfileSyncService::ConfigureDataTypeManager() {
   // Don't configure datatypes if the setup UI is still on the screen - this
   // is to help multi-screen setting UIs (like iOS) where they don't want to
   // start syncing data until the user is done configuring encryption options,
   // etc. ReconfigureDatatypeManager() will get called again once the UI calls
   // SetSetupInProgress(false).
   if (!CanConfigureDataTypes()) {
     // If we can't configure the data type manager yet, we should still notify
     // observers. This is to support multiple setup UIs being open at once.
     NotifyObservers();
     return;
   }
 
   bool restart = false;
   if (!data_type_manager_) {
     restart = true;
     data_type_manager_.reset(
         sync_client_->GetSyncApiComponentFactory()->CreateDataTypeManager(
-            debug_info_listener_, &data_type_controllers_, this, backend_.get(),
+            debug_info_listener_, &data_type_controllers_, this, engine_.get(),
             this));
 
     // We create the migrator at the same time.
     migrator_ = base::MakeUnique<BackendMigrator>(
         debug_identifier_, GetUserShare(), this, data_type_manager_.get(),
         base::Bind(&ProfileSyncService::StartSyncingWithServer,
                    base::Unretained(this)));
   }
 
   syncer::ModelTypeSet types;
   syncer::ConfigureReason reason = syncer::CONFIGURE_REASON_UNKNOWN;
   types = GetPreferredDataTypes();
   if (restart) {
     // Datatype downloads on restart are generally due to newly supported
     // datatypes (although it's also possible we're picking up where a failed
     // previous configuration left off).
     // TODO(sync): consider detecting configuration recovery and setting
     // the reason here appropriately.
     reason = syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE;
   } else {
     // The user initiated a reconfiguration (either to add or remove types).
     reason = syncer::CONFIGURE_REASON_RECONFIGURATION;
   }
 
   data_type_manager_->Configure(types, reason);
 }
 
 syncer::UserShare* ProfileSyncService::GetUserShare() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (backend_.get() && backend_initialized_) {
-    return backend_->GetUserShare();
+  if (engine_ && engine_initialized_) {
+    return engine_->GetUserShare();
   }
   NOTREACHED();
   return nullptr;
 }
 
 syncer::SyncCycleSnapshot ProfileSyncService::GetLastCycleSnapshot() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (backend_)
-    return backend_->GetLastCycleSnapshot();
+  if (engine_)
+    return engine_->GetLastCycleSnapshot();
   return syncer::SyncCycleSnapshot();
 }
 
 bool ProfileSyncService::HasUnsyncedItems() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (HasSyncingBackend() && backend_initialized_) {
-    return backend_->HasUnsyncedItems();
+  if (HasSyncingEngine() && engine_initialized_) {
+    return engine_->HasUnsyncedItems();
   }
   NOTREACHED();
   return false;
 }
 
 BackendMigrator* ProfileSyncService::GetBackendMigratorForTest() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return migrator_.get();
 }
 
 void ProfileSyncService::GetModelSafeRoutingInfo(
     syncer::ModelSafeRoutingInfo* out) const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (backend_.get() && backend_initialized_) {
-    backend_->GetModelSafeRoutingInfo(out);
+  if (engine_ && engine_initialized_) {
+    engine_->GetModelSafeRoutingInfo(out);
   } else {
     NOTREACHED();
   }
 }
 
 std::unique_ptr<base::Value> ProfileSyncService::GetTypeStatusMap() {
   DCHECK(thread_checker_.CalledOnValidThread());
   auto result = base::MakeUnique<base::ListValue>();
 
-  if (!backend_.get() || !backend_initialized_) {
+  if (!engine_ || !engine_initialized_) {
     return std::move(result);
   }
 
   DataTypeStatusTable::TypeErrorMap error_map =
       data_type_status_table_.GetAllErrors();
   ModelTypeSet active_types;
   ModelTypeSet passive_types;
   ModelSafeRoutingInfo routing_info;
-  backend_->GetModelSafeRoutingInfo(&routing_info);
+  engine_->GetModelSafeRoutingInfo(&routing_info);
   for (ModelSafeRoutingInfo::const_iterator it = routing_info.begin();
        it != routing_info.end(); ++it) {
     if (it->second == syncer::GROUP_PASSIVE) {
       passive_types.Put(it->first);
     } else {
       active_types.Put(it->first);
     }
   }
 
-  SyncEngine::Status detailed_status = backend_->GetDetailedStatus();
+  SyncEngine::Status detailed_status = engine_->GetDetailedStatus();
   ModelTypeSet& throttled_types(detailed_status.throttled_types);
   ModelTypeSet& backed_off_types(detailed_status.backed_off_types);
   ModelTypeSet registered = GetRegisteredDataTypes();
   std::unique_ptr<base::DictionaryValue> type_status_header(
       new base::DictionaryValue());
 
   type_status_header->SetString("name", "Model Type");
   type_status_header->SetString("status", "header");
   type_status_header->SetString("value", "Group Type");
   type_status_header->SetString("num_entries", "Total Entries");
@@ skipping 63 matching lines @@
           base::Bind(&ProfileSyncService::OnDatatypeStatusCounterUpdated,
                      base::Unretained(this))));
     }
 
     result->Append(std::move(type_status));
   }
   return std::move(result);
 }
 
 void ProfileSyncService::ConsumeCachedPassphraseIfPossible() {
-  // If no cached passphrase, or sync backend hasn't started up yet, just exit.
-  // If the backend isn't running yet, OnBackendInitialized() will call this
-  // method again after the backend starts up.
-  if (cached_passphrase_.empty() || !IsBackendInitialized())
+  // If no cached passphrase, or sync engine hasn't started up yet, just exit.
+  // If the engine isn't running yet, OnEngineInitialized() will call this
+  // method again after the engine starts up.
+  if (cached_passphrase_.empty() || !IsEngineInitialized())
     return;
 
-  // Backend is up and running, so we can consume the cached passphrase.
+  // Engine is up and running, so we can consume the cached passphrase.
   std::string passphrase = cached_passphrase_;
   cached_passphrase_.clear();
 
   // If we need a passphrase to decrypt data, try the cached passphrase.
   if (passphrase_required_reason() == syncer::REASON_DECRYPTION) {
     if (SetDecryptionPassphrase(passphrase)) {
       DVLOG(1) << "Cached passphrase successfully decrypted pending keys";
       return;
     }
   }
@@ skipping 26 matching lines @@
   token_request_time_ = base::Time::Now();
   token_receive_time_ = base::Time();
   next_token_request_time_ = base::Time();
   access_token_request_ =
       oauth2_token_service_->StartRequest(account_id, oauth2_scopes, this);
 }
 
 void ProfileSyncService::SetEncryptionPassphrase(const std::string& passphrase,
                                                  PassphraseType type) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  // This should only be called when the backend has been initialized.
-  DCHECK(IsBackendInitialized());
+  // This should only be called when the engine has been initialized.
+  DCHECK(IsEngineInitialized());
   DCHECK(!(type == IMPLICIT && IsUsingSecondaryPassphrase()))
       << "Data is already encrypted using an explicit passphrase";
   DCHECK(!(type == EXPLICIT &&
            passphrase_required_reason_ == syncer::REASON_DECRYPTION))
       << "Can not set explicit passphrase when decryption is needed.";
 
   DVLOG(1) << "Setting " << (type == EXPLICIT ? "explicit" : "implicit")
            << " passphrase for encryption.";
   if (passphrase_required_reason_ == syncer::REASON_ENCRYPTION) {
     // REASON_ENCRYPTION implies that the cryptographer does not have pending
     // keys. Hence, as long as we're not trying to do an invalid passphrase
     // change (e.g. explicit -> explicit or explicit -> implicit), we know this
     // will succeed. If for some reason a new encryption key arrives via
     // sync later, the SBH will trigger another OnPassphraseRequired().
     passphrase_required_reason_ = syncer::REASON_PASSPHRASE_NOT_REQUIRED;
     NotifyObservers();
   }
-  backend_->SetEncryptionPassphrase(passphrase, type == EXPLICIT);
+  engine_->SetEncryptionPassphrase(passphrase, type == EXPLICIT);
 }
 
 bool ProfileSyncService::SetDecryptionPassphrase(
     const std::string& passphrase) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (IsPassphraseRequired()) {
     DVLOG(1) << "Setting passphrase for decryption.";
-    bool result = backend_->SetDecryptionPassphrase(passphrase);
+    bool result = engine_->SetDecryptionPassphrase(passphrase);
     UMA_HISTOGRAM_BOOLEAN("Sync.PassphraseDecryptionSucceeded", result);
     return result;
   } else {
     NOTREACHED() << "SetDecryptionPassphrase must not be called when "
                     "IsPassphraseRequired() is false.";
     return false;
   }
 }
 
 bool ProfileSyncService::IsEncryptEverythingAllowed() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return encrypt_everything_allowed_;
 }
 
 void ProfileSyncService::SetEncryptEverythingAllowed(bool allowed) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(allowed || !IsBackendInitialized() || !IsEncryptEverythingEnabled());
+  DCHECK(allowed || !IsEngineInitialized() || !IsEncryptEverythingEnabled());
   encrypt_everything_allowed_ = allowed;
 }
 
 void ProfileSyncService::EnableEncryptEverything() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsEncryptEverythingAllowed());
 
-  // Tests override IsBackendInitialized() to always return true, so we
-  // must check that instead of |backend_initialized_|.
+  // Tests override IsEngineInitialized() to always return true, so we
+  // must check that instead of |engine_initialized_|.
   // TODO(akalin): Fix the above. :/
-  DCHECK(IsBackendInitialized());
+  DCHECK(IsEngineInitialized());
   // TODO(atwilson): Persist the encryption_pending_ flag to address the various
   // problems around cancelling encryption in the background (crbug.com/119649).
   if (!encrypt_everything_)
     encryption_pending_ = true;
 }
 
 bool ProfileSyncService::encryption_pending() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   // We may be called during the setup process before we're
   // initialized (via IsEncryptedDatatypeEnabled and
   // IsPassphraseRequiredForDecryption).
   return encryption_pending_;
 }
 
 bool ProfileSyncService::IsEncryptEverythingEnabled() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(backend_initialized_);
+  DCHECK(engine_initialized_);
   return encrypt_everything_ || encryption_pending_;
 }
 
 syncer::ModelTypeSet ProfileSyncService::GetEncryptedDataTypes() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(encrypted_types_.Has(syncer::PASSWORDS));
   // We may be called during the setup process before we're
   // initialized.  In this case, we default to the sensitive types.
   return encrypted_types_;
 }
 
 void ProfileSyncService::OnSyncManagedPrefChange(bool is_sync_managed) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (is_sync_managed) {
     StopImpl(CLEAR_DATA);
   } else {
     // Sync is no longer disabled by policy. Try starting it up if appropriate.
     startup_controller_->TryStart();
   }
 }
 
 void ProfileSyncService::GoogleSigninSucceeded(const std::string& account_id,
                                                const std::string& username,
                                                const std::string& password) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (IsSyncRequested() && !password.empty()) {
     cached_passphrase_ = password;
-    // Try to consume the passphrase we just cached. If the sync backend
+    // Try to consume the passphrase we just cached. If the sync engine
     // is not running yet, the passphrase will remain cached until the
-    // backend starts up.
+    // engine starts up.
     ConsumeCachedPassphraseIfPossible();
   }
 #if defined(OS_CHROMEOS)
   RefreshSpareBootstrapToken(password);
 #endif
-  if (!IsBackendInitialized() || GetAuthError().state() != AuthError::NONE) {
+  if (!IsEngineInitialized() || GetAuthError().state() != AuthError::NONE) {
     // Track the fact that we're still waiting for auth to complete.
     is_auth_in_progress_ = true;
   }
 }
 
 void ProfileSyncService::GoogleSignedOut(const std::string& account_id,
                                          const std::string& username) {
   DCHECK(thread_checker_.CalledOnValidThread());
   sync_disabled_by_admin_ = false;
   UMA_HISTOGRAM_ENUMERATION("Sync.StopSource", syncer::SIGN_OUT,
                             syncer::STOP_SOURCE_LIMIT);
   RequestStop(CLEAR_DATA);
 }
 
 void ProfileSyncService::OnGaiaAccountsInCookieUpdated(
     const std::vector<gaia::ListedAccount>& accounts,
     const std::vector<gaia::ListedAccount>& signed_out_accounts,
     const GoogleServiceAuthError& error) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!IsBackendInitialized())
+  if (!IsEngineInitialized())
     return;
 
   bool cookie_jar_mismatch = true;
   bool cookie_jar_empty = accounts.size() == 0;
   std::string account_id = signin_->GetAccountIdToUse();
 
   // Iterate through list of accounts, looking for current sync account.
   for (const auto& account : accounts) {
     if (account.id == account_id) {
       cookie_jar_mismatch = false;
       break;
     }
   }
 
   DVLOG(1) << "Cookie jar mismatch: " << cookie_jar_mismatch;
   DVLOG(1) << "Cookie jar empty: " << cookie_jar_empty;
-  backend_->OnCookieJarChanged(cookie_jar_mismatch, cookie_jar_empty);
+  engine_->OnCookieJarChanged(cookie_jar_mismatch, cookie_jar_empty);
 }
 
 void ProfileSyncService::AddObserver(syncer::SyncServiceObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observers_.AddObserver(observer);
 }
 
 void ProfileSyncService::RemoveObserver(syncer::SyncServiceObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observers_.RemoveObserver(observer);
 }
 
 void ProfileSyncService::AddProtocolEventObserver(
     ProtocolEventObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   protocol_event_observers_.AddObserver(observer);
-  if (HasSyncingBackend()) {
-    backend_->RequestBufferedProtocolEventsAndEnableForwarding();
+  if (HasSyncingEngine()) {
+    engine_->RequestBufferedProtocolEventsAndEnableForwarding();
   }
 }
 
 void ProfileSyncService::RemoveProtocolEventObserver(
     ProtocolEventObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   protocol_event_observers_.RemoveObserver(observer);
-  if (HasSyncingBackend() &&
-      !protocol_event_observers_.might_have_observers()) {
-    backend_->DisableProtocolEventForwarding();
+  if (HasSyncingEngine() && !protocol_event_observers_.might_have_observers()) {
+    engine_->DisableProtocolEventForwarding();
   }
 }
 
 void ProfileSyncService::AddTypeDebugInfoObserver(
     syncer::TypeDebugInfoObserver* type_debug_info_observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   type_debug_info_observers_.AddObserver(type_debug_info_observer);
   if (type_debug_info_observers_.might_have_observers() &&
-      backend_initialized_) {
-    backend_->EnableDirectoryTypeDebugInfoForwarding();
+      engine_initialized_) {
+    engine_->EnableDirectoryTypeDebugInfoForwarding();
   }
 }
 
 void ProfileSyncService::RemoveTypeDebugInfoObserver(
     syncer::TypeDebugInfoObserver* type_debug_info_observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   type_debug_info_observers_.RemoveObserver(type_debug_info_observer);
   if (!type_debug_info_observers_.might_have_observers() &&
-      backend_initialized_) {
-    backend_->DisableDirectoryTypeDebugInfoForwarding();
+      engine_initialized_) {
+    engine_->DisableDirectoryTypeDebugInfoForwarding();
   }
 }
 
 void ProfileSyncService::AddPreferenceProvider(
     syncer::SyncTypePreferenceProvider* provider) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!HasPreferenceProvider(provider))
       << "Providers may only be added once!";
   preference_providers_.insert(provider);
 }
@@ skipping 72 matching lines @@
 }  // namespace
 
 void ProfileSyncService::GetAllNodes(
     const base::Callback<void(std::unique_ptr<base::ListValue>)>& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ModelTypeSet all_types = GetActiveDataTypes();
   all_types.PutAll(syncer::ControlTypes());
   scoped_refptr<GetAllNodesRequestHelper> helper =
       new GetAllNodesRequestHelper(all_types, callback);
 
-  if (!backend_initialized_) {
-    // If there's no backend available to fulfill the request, handle it here.
+  if (!engine_initialized_) {
+    // If there's no engine available to fulfill the request, handle it here.
     for (ModelTypeSet::Iterator it = all_types.First(); it.Good(); it.Inc()) {
       helper->OnReceivedNodesForType(it.Get(),
                                      base::MakeUnique<base::ListValue>());
     }
     return;
   }
 
   for (ModelTypeSet::Iterator it = all_types.First(); it.Good(); it.Inc()) {
     const auto& dtc_iter = data_type_controllers_.find(it.Get());
     if (dtc_iter != data_type_controllers_.end()) {
@@ skipping 71 matching lines @@
     sync_prefs_.SetSyncRequested(true);
     NotifyObservers();
   }
   startup_controller_->TryStartImmediately();
 }
 
 void ProfileSyncService::ReconfigureDatatypeManager() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // If we haven't initialized yet, don't configure the DTM as it could cause
   // association to start before a Directory has even been created.
-  if (backend_initialized_) {
-    DCHECK(backend_.get());
+  if (engine_initialized_) {
+    DCHECK(engine_);
     ConfigureDataTypeManager();
   } else if (HasUnrecoverableError()) {
     // There is nothing more to configure. So inform the listeners,
     NotifyObservers();
 
     DVLOG(1) << "ConfigureDataTypeManager not invoked because of an "
              << "Unrecoverable error.";
   } else {
-    DVLOG(0) << "ConfigureDataTypeManager not invoked because backend is not "
+    DVLOG(0) << "ConfigureDataTypeManager not invoked because engine is not "
              << "initialized";
   }
 }
 
 syncer::ModelTypeSet ProfileSyncService::GetDataTypesFromPreferenceProviders()
     const {
   syncer::ModelTypeSet types;
   for (std::set<syncer::SyncTypePreferenceProvider*>::const_iterator it =
            preference_providers_.begin();
        it != preference_providers_.end(); ++it) {
@@ skipping 59 matching lines @@
     status.next_token_request_time = next_token_request_time_;
   return status;
 }
 
 void ProfileSyncService::OverrideNetworkResourcesForTest(
     std::unique_ptr<syncer::NetworkResources> network_resources) {
   DCHECK(thread_checker_.CalledOnValidThread());
   network_resources_ = std::move(network_resources);
 }
 
-bool ProfileSyncService::HasSyncingBackend() const {
-  return backend_ != nullptr;
+bool ProfileSyncService::HasSyncingEngine() const {
+  return engine_ != nullptr;
 }
 
 void ProfileSyncService::UpdateFirstSyncTimePref() {
   if (!IsSignedIn()) {
     sync_prefs_.ClearFirstSyncTime();
   } else if (sync_prefs_.GetFirstSyncTime().is_null()) {
     // Set if not set before and it's syncing now.
     sync_prefs_.SetFirstSyncTime(base::Time::Now());
   }
 }
 
 void ProfileSyncService::FlushDirectory() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  // backend_initialized_ implies backend_ isn't null and the manager exists.
+  // engine_initialized_ implies engine_ isn't null and the manager exists.
   // If sync is not initialized yet, we fail silently.
-  if (backend_initialized_)
-    backend_->FlushDirectory();
+  if (engine_initialized_)
+    engine_->FlushDirectory();
 }
 
 base::FilePath ProfileSyncService::GetDirectoryPathForTest() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return directory_path_;
 }
 
 base::MessageLoop* ProfileSyncService::GetSyncLoopForTest() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (sync_thread_) {
     return sync_thread_->message_loop();
   } else {
     return nullptr;
   }
 }
 
 void ProfileSyncService::RefreshTypesForTest(syncer::ModelTypeSet types) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (backend_initialized_)
-    backend_->RefreshTypesForTest(types);
+  if (engine_initialized_)
+    engine_->RefreshTypesForTest(types);
 }
 
 void ProfileSyncService::RemoveClientFromServer() const {
-  if (!backend_initialized_)
+  if (!engine_initialized_)
     return;
   const std::string cache_guid = local_device_->GetLocalSyncCacheGUID();
   std::string birthday;
   syncer::UserShare* user_share = GetUserShare();
   if (user_share && user_share->directory.get()) {
     birthday = user_share->directory->store_birthday();
   }
   if (!access_token_.empty() && !cache_guid.empty() && !birthday.empty()) {
     sync_stopped_reporter_->ReportSyncStopped(access_token_, cache_guid,
                                               birthday);
@@ skipping 47 matching lines @@
 void ProfileSyncService::OnSetupInProgressHandleDestroyed() {
   DCHECK_GT(outstanding_setup_in_progress_handles_, 0);
 
   // Don't re-start Sync until all outstanding handles are destroyed.
   if (--outstanding_setup_in_progress_handles_ != 0)
     return;
 
   DCHECK(startup_controller_->IsSetupInProgress());
   startup_controller_->SetSetupInProgress(false);
 
-  if (IsBackendInitialized())
+  if (IsEngineInitialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }
 
 }  // namespace browser_sync