[Sync] SyncEngine refactor part 1: interfaces.

components/browser_sync/profile_sync_service_unittest.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 <utility>
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/sequenced_worker_pool_owner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "components/browser_sync/browser_sync_switches.h"
 #include "components/browser_sync/profile_sync_test_util.h"
 #include "components/invalidation/impl/profile_invalidation_provider.h"
 #include "components/invalidation/public/invalidation_service.h"
 #include "components/signin/core/browser/account_tracker_service.h"
 #include "components/signin/core/browser/fake_signin_manager.h"
 #include "components/strings/grit/components_strings.h"
 #include "components/sync/base/pref_names.h"
 #include "components/sync/driver/fake_data_type_controller.h"
-#include "components/sync/driver/glue/sync_backend_host_mock.h"
 #include "components/sync/driver/sync_api_component_factory_mock.h"
 #include "components/sync/driver/sync_driver_switches.h"
 #include "components/sync/driver/sync_service_observer.h"
 #include "components/sync/driver/sync_util.h"
+#include "components/sync/engine/fake_sync_engine.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "components/version_info/version_info_values.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using syncer::DataTypeController;
-using syncer::SyncBackendHostMock;
+using syncer::FakeSyncEngine;
 using syncer::SyncMergeResult;
 using testing::Return;
 
 namespace browser_sync {
 
 namespace {
 
 const char kGaiaId[] = "12345";
 const char kEmail[] = "test_user@gmail.com";
 
@@ skipping 38 matching lines @@
   void OnStateChanged() override {
     setup_in_progress_ = service_->IsSetupInProgress();
   }
   bool setup_in_progress() const { return setup_in_progress_; }
 
  private:
   ProfileSyncService* service_;
   bool setup_in_progress_;
 };
 
-// A variant of the SyncBackendHostMock that won't automatically
-// call back when asked to initialized.  Allows us to test things
-// that could happen while backend init is in progress.
-class SyncBackendHostNoReturn : public SyncBackendHostMock {
+// A variant of the FakeSyncEngine that won't automatically call back when asked
+// to initialized. Allows us to test things that could happen while backend init
+// is in progress.
+class SyncEngineNoReturn : public FakeSyncEngine {
   void Initialize(
-      syncer::SyncFrontend* frontend,
+      syncer::SyncEngineHost* host,
       scoped_refptr<base::SingleThreadTaskRunner> sync_task_runner,
       const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
       const GURL& service_url,
       const std::string& sync_user_agent,
       const syncer::SyncCredentials& credentials,
       bool delete_sync_data_folder,
       bool enable_local_sync_backend,
       const base::FilePath& local_sync_backend_folder,
       std::unique_ptr<syncer::SyncManagerFactory> sync_manager_factory,
       const syncer::WeakHandle<syncer::UnrecoverableErrorHandler>&
           unrecoverable_error_handler,
       const base::Closure& report_unrecoverable_error_function,
       const HttpPostProviderFactoryGetter& http_post_provider_factory_getter,
       std::unique_ptr<syncer::SyncEncryptionHandler::NigoriState>
           saved_nigori_state) override {}
 };
 
-class SyncBackendHostMockCollectDeleteDirParam : public SyncBackendHostMock {
+class FakeSyncEngineCollectDeleteDirParam : public FakeSyncEngine {
  public:
-  explicit SyncBackendHostMockCollectDeleteDirParam(
+  explicit FakeSyncEngineCollectDeleteDirParam(
       std::vector<bool>* delete_dir_param)
       : delete_dir_param_(delete_dir_param) {}
 
   void Initialize(
-      syncer::SyncFrontend* frontend,
+      syncer::SyncEngineHost* host,
       scoped_refptr<base::SingleThreadTaskRunner> sync_task_runner,
       const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
       const GURL& service_url,
       const std::string& sync_user_agent,
       const syncer::SyncCredentials& credentials,
       bool delete_sync_data_folder,
       bool enable_local_sync_backend,
       const base::FilePath& local_sync_backend_folder,
       std::unique_ptr<syncer::SyncManagerFactory> sync_manager_factory,
       const syncer::WeakHandle<syncer::UnrecoverableErrorHandler>&
           unrecoverable_error_handler,
       const base::Closure& report_unrecoverable_error_function,
       const HttpPostProviderFactoryGetter& http_post_provider_factory_getter,
       std::unique_ptr<syncer::SyncEncryptionHandler::NigoriState>
           saved_nigori_state) override {
     delete_dir_param_->push_back(delete_sync_data_folder);
-    SyncBackendHostMock::Initialize(
-        frontend, std::move(sync_task_runner), event_handler, service_url,
+    FakeSyncEngine::Initialize(
+        host, std::move(sync_task_runner), event_handler, service_url,
         sync_user_agent, credentials, delete_sync_data_folder,
         enable_local_sync_backend, local_sync_backend_folder,
         std::move(sync_manager_factory), unrecoverable_error_handler,
         report_unrecoverable_error_function, http_post_provider_factory_getter,
         std::move(saved_nigori_state));
   }
 
  private:
   std::vector<bool>* delete_dir_param_;
 };
 
-// SyncBackendHostMock that calls an external callback when ClearServerData is
+// FakeSyncEngine that calls an external callback when ClearServerData is
 // called.
-class SyncBackendHostCaptureClearServerData : public SyncBackendHostMock {
+class SyncEngineCaptureClearServerData : public FakeSyncEngine {
  public:
   typedef base::Callback<void(
       const syncer::SyncManager::ClearServerDataCallback&)>
       ClearServerDataCalled;
-  explicit SyncBackendHostCaptureClearServerData(
+  explicit SyncEngineCaptureClearServerData(
       const ClearServerDataCalled& clear_server_data_called)
       : clear_server_data_called_(clear_server_data_called) {}
 
   void ClearServerData(
       const syncer::SyncManager::ClearServerDataCallback& callback) override {
     clear_server_data_called_.Run(callback);
   }
 
  private:
   ClearServerDataCalled clear_server_data_called_;
 };
 
-ACTION(ReturnNewSyncBackendHostMock) {
-  return new SyncBackendHostMock();
+ACTION(ReturnNewFakeSyncEngine) {
+  return new FakeSyncEngine();
 }
 
-ACTION(ReturnNewSyncBackendHostNoReturn) {
-  return new SyncBackendHostNoReturn();
+ACTION(ReturnNewSyncEngineNoReturn) {
+  return new SyncEngineNoReturn();
 }
 
 ACTION_P(ReturnNewMockHostCollectDeleteDirParam, delete_dir_param) {
-  return new SyncBackendHostMockCollectDeleteDirParam(delete_dir_param);
+  return new FakeSyncEngineCollectDeleteDirParam(delete_dir_param);
 }
 
 void OnClearServerDataCalled(
     syncer::SyncManager::ClearServerDataCallback* captured_callback,
     const syncer::SyncManager::ClearServerDataCallback& callback) {
   *captured_callback = callback;
 }
 
 ACTION_P(ReturnNewMockHostCaptureClearServerData, captured_callback) {
-  return new SyncBackendHostCaptureClearServerData(base::Bind(
+  return new SyncEngineCaptureClearServerData(base::Bind(
       &OnClearServerDataCalled, base::Unretained(captured_callback)));
 }
 
 void DoNothing(DataTypeController::ConfigureResult ignored1,
                const SyncMergeResult& ignored2,
                const SyncMergeResult& ignored3) {}
 
 // A test harness that uses a real ProfileSyncService and in most cases a
-// MockSyncBackendHost.
+// MockSyncEngine.
 //
 // This is useful if we want to test the ProfileSyncService and don't care about
-// testing the SyncBackendHost.
+// testing the SyncEngine.
 class ProfileSyncServiceTest : public ::testing::Test {
  protected:
   ProfileSyncServiceTest() : component_factory_(nullptr) {}
   ~ProfileSyncServiceTest() override {}
 
   void SetUp() override {
     base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
         switches::kSyncDeferredStartupTimeoutSeconds, "0");
   }
 
@@ skipping 84 matching lines @@
   }
 
   void ExpectDataTypeManagerCreation(
       int times,
       const FakeDataTypeManager::ConfigureCalled& callback) {
     EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _))
         .Times(times)
         .WillRepeatedly(ReturnNewDataTypeManager(callback));
   }
 
-  void ExpectSyncBackendHostCreation(int times) {
-    EXPECT_CALL(*component_factory_, CreateSyncBackendHost(_, _, _, _))
+  void ExpectSyncEngineCreation(int times) {
+    EXPECT_CALL(*component_factory_, CreateSyncEngine(_, _, _, _))
         .Times(times)
-        .WillRepeatedly(ReturnNewSyncBackendHostMock());
+        .WillRepeatedly(ReturnNewFakeSyncEngine());
   }
 
-  void ExpectSyncBackendHostCreationCollectDeleteDir(
+  void ExpectSyncEngineCreationCollectDeleteDir(
       int times,
       std::vector<bool>* delete_dir_param) {
-    EXPECT_CALL(*component_factory_, CreateSyncBackendHost(_, _, _, _))
+    EXPECT_CALL(*component_factory_, CreateSyncEngine(_, _, _, _))
         .Times(times)
         .WillRepeatedly(
             ReturnNewMockHostCollectDeleteDirParam(delete_dir_param));
   }
 
-  void ExpectSyncBackendHostCreationCaptureClearServerData(
+  void ExpectSyncEngineCreationCaptureClearServerData(
       syncer::SyncManager::ClearServerDataCallback* captured_callback) {
-    EXPECT_CALL(*component_factory_, CreateSyncBackendHost(_, _, _, _))
+    EXPECT_CALL(*component_factory_, CreateSyncEngine(_, _, _, _))
         .Times(1)
         .WillOnce(ReturnNewMockHostCaptureClearServerData(captured_callback));
   }
 
-  void PrepareDelayedInitSyncBackendHost() {
-    EXPECT_CALL(*component_factory_, CreateSyncBackendHost(_, _, _, _))
-        .WillOnce(ReturnNewSyncBackendHostNoReturn());
+  void PrepareDelayedInitSyncEngine() {
+    EXPECT_CALL(*component_factory_, CreateSyncEngine(_, _, _, _))
+        .WillOnce(ReturnNewSyncEngineNoReturn());
   }
 
   AccountTrackerService* account_tracker() {
     return profile_sync_service_bundle_.account_tracker();
   }
 
 #if defined(OS_CHROMEOS)
   SigninManagerBase* signin_manager()
 #else
   SigninManager* signin_manager()
@@ skipping 44 matching lines @@
               url == syncer::internal::kSyncDevServerUrl);
 }
 
 // Verify a successful initialization.
 TEST_F(ProfileSyncServiceTest, SuccessfulInitialization) {
   prefs()->SetManagedPref(syncer::prefs::kSyncManaged,
                           new base::FundamentalValue(false));
   IssueTestTokens();
   CreateService(ProfileSyncService::AUTO_START);
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
-  ExpectSyncBackendHostCreation(1);
+  ExpectSyncEngineCreation(1);
   InitializeForNthSync();
   EXPECT_FALSE(service()->IsManaged());
   EXPECT_TRUE(service()->IsSyncActive());
 }
 
 // Verify that an initialization where first setup is not complete does not
 // start up the backend.
 TEST_F(ProfileSyncServiceTest, NeedsConfirmation) {
   prefs()->SetManagedPref(syncer::prefs::kSyncManaged,
                           new base::FundamentalValue(false));
@@ skipping 39 matching lines @@
   EXPECT_TRUE(service()->IsManaged());
   EXPECT_FALSE(service()->IsSyncActive());
 }
 
 // Verify that disable by enterprise policy works even after the backend has
 // been initialized.
 TEST_F(ProfileSyncServiceTest, DisabledByPolicyAfterInit) {
   IssueTestTokens();
   CreateService(ProfileSyncService::AUTO_START);
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
-  ExpectSyncBackendHostCreation(1);
+  ExpectSyncEngineCreation(1);
   InitializeForNthSync();
 
   EXPECT_FALSE(service()->IsManaged());
   EXPECT_TRUE(service()->IsSyncActive());
 
   prefs()->SetManagedPref(syncer::prefs::kSyncManaged,
                           new base::FundamentalValue(true));
 
   EXPECT_TRUE(service()->IsManaged());
   EXPECT_FALSE(service()->IsSyncActive());
 }
 
 // Exercies the ProfileSyncService's code paths related to getting shut down
 // before the backend initialize call returns.
 TEST_F(ProfileSyncServiceTest, AbortedByShutdown) {
   CreateService(ProfileSyncService::AUTO_START);
-  PrepareDelayedInitSyncBackendHost();
+  PrepareDelayedInitSyncEngine();
 
   IssueTestTokens();
   InitializeForNthSync();
   EXPECT_FALSE(service()->IsSyncActive());
 
   ShutdownAndDeleteService();
 }
 
 // Test RequestStop() before we've initialized the backend.
 TEST_F(ProfileSyncServiceTest, EarlyRequestStop) {
   CreateService(ProfileSyncService::AUTO_START);
   IssueTestTokens();
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
-  ExpectSyncBackendHostCreation(1);
+  ExpectSyncEngineCreation(1);
 
   service()->RequestStop(ProfileSyncService::KEEP_DATA);
   EXPECT_FALSE(service()->IsSyncRequested());
 
   // Because sync is not requested, this should fail.
   InitializeForNthSync();
   EXPECT_FALSE(service()->IsSyncRequested());
   EXPECT_FALSE(service()->IsSyncActive());
 
   // Request start. This should be enough to allow init to happen.
   service()->RequestStart();
   EXPECT_TRUE(service()->IsSyncRequested());
   EXPECT_TRUE(service()->IsSyncActive());
 }
 
 // Test RequestStop() after we've initialized the backend.
 TEST_F(ProfileSyncServiceTest, DisableAndEnableSyncTemporarily) {
   CreateService(ProfileSyncService::AUTO_START);
   IssueTestTokens();
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
-  ExpectSyncBackendHostCreation(1);
+  ExpectSyncEngineCreation(1);
   InitializeForNthSync();
 
   EXPECT_TRUE(service()->IsSyncActive());
   EXPECT_FALSE(prefs()->GetBoolean(syncer::prefs::kSyncSuppressStart));
 
   testing::Mock::VerifyAndClearExpectations(component_factory());
 
   service()->RequestStop(ProfileSyncService::KEEP_DATA);
   EXPECT_FALSE(service()->IsSyncActive());
   EXPECT_TRUE(prefs()->GetBoolean(syncer::prefs::kSyncSuppressStart));
 
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
-  ExpectSyncBackendHostCreation(1);
+  ExpectSyncEngineCreation(1);
 
   service()->RequestStart();
   EXPECT_TRUE(service()->IsSyncActive());
   EXPECT_FALSE(prefs()->GetBoolean(syncer::prefs::kSyncSuppressStart));
 }
 
 // Certain ProfileSyncService tests don't apply to Chrome OS, for example
 // things that deal with concepts like "signing out" and policy.
 #if !defined(OS_CHROMEOS)
 TEST_F(ProfileSyncServiceTest, EnableSyncAndSignOut) {
   CreateService(ProfileSyncService::AUTO_START);
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
-  ExpectSyncBackendHostCreation(1);
+  ExpectSyncEngineCreation(1);
   IssueTestTokens();
   InitializeForNthSync();
 
   EXPECT_TRUE(service()->IsSyncActive());
   EXPECT_FALSE(prefs()->GetBoolean(syncer::prefs::kSyncSuppressStart));
 
   signin_manager()->SignOut(signin_metrics::SIGNOUT_TEST,
                             signin_metrics::SignoutDelete::IGNORE_METRIC);
   EXPECT_FALSE(service()->IsSyncActive());
 }
 #endif  // !defined(OS_CHROMEOS)
 
 TEST_F(ProfileSyncServiceTest, GetSyncTokenStatus) {
   CreateService(ProfileSyncService::AUTO_START);
   IssueTestTokens();
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
-  ExpectSyncBackendHostCreation(1);
+  ExpectSyncEngineCreation(1);
   InitializeForNthSync();
 
   // Initial status.
   ProfileSyncService::SyncTokenStatus token_status =
       service()->GetSyncTokenStatus();
   EXPECT_EQ(syncer::CONNECTION_NOT_ATTEMPTED, token_status.connection_status);
   EXPECT_TRUE(token_status.connection_status_update_time.is_null());
   EXPECT_TRUE(token_status.token_request_time.is_null());
   EXPECT_TRUE(token_status.token_receive_time.is_null());
 
@@ skipping 16 matching lines @@
   // Simulate successful connection.
   service()->OnConnectionStatusChange(syncer::CONNECTION_OK);
   token_status = service()->GetSyncTokenStatus();
   EXPECT_EQ(syncer::CONNECTION_OK, token_status.connection_status);
 }
 
 TEST_F(ProfileSyncServiceTest, RevokeAccessTokenFromTokenService) {
   CreateService(ProfileSyncService::AUTO_START);
   IssueTestTokens();
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
-  ExpectSyncBackendHostCreation(1);
+  ExpectSyncEngineCreation(1);
   InitializeForNthSync();
   EXPECT_TRUE(service()->IsSyncActive());
 
   std::string primary_account_id =
       signin_manager()->GetAuthenticatedAccountId();
   auth_service()->LoadCredentials(primary_account_id);
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(service()->GetAccessTokenForTest().empty());
 
   std::string secondary_account_gaiaid = "1234567";
   std::string secondary_account_name = "test_user2@gmail.com";
   std::string secondary_account_id = account_tracker()->SeedAccountInfo(
       secondary_account_gaiaid, secondary_account_name);
   auth_service()->UpdateCredentials(secondary_account_id,
                                     "second_account_refresh_token");
   auth_service()->RevokeCredentials(secondary_account_id);
   EXPECT_FALSE(service()->GetAccessTokenForTest().empty());
 
   auth_service()->RevokeCredentials(primary_account_id);
   EXPECT_TRUE(service()->GetAccessTokenForTest().empty());
 }
 
 // CrOS does not support signout.
 #if !defined(OS_CHROMEOS)
 TEST_F(ProfileSyncServiceTest, SignOutRevokeAccessToken) {
   CreateService(ProfileSyncService::AUTO_START);
   IssueTestTokens();
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
-  ExpectSyncBackendHostCreation(1);
+  ExpectSyncEngineCreation(1);
   InitializeForNthSync();
   EXPECT_TRUE(service()->IsSyncActive());
 
   std::string primary_account_id =
       signin_manager()->GetAuthenticatedAccountId();
   auth_service()->LoadCredentials(primary_account_id);
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(service()->GetAccessTokenForTest().empty());
 
   signin_manager()->SignOut(signin_metrics::SIGNOUT_TEST,
                             signin_metrics::SignoutDelete::IGNORE_METRIC);
   EXPECT_TRUE(service()->GetAccessTokenForTest().empty());
 }
 #endif
 
 // Verify that LastSyncedTime and local DeviceInfo is cleared on sign out.
 TEST_F(ProfileSyncServiceTest, ClearDataOnSignOut) {
   IssueTestTokens();
   CreateService(ProfileSyncService::AUTO_START);
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
-  ExpectSyncBackendHostCreation(1);
+  ExpectSyncEngineCreation(1);
   InitializeForNthSync();
   EXPECT_TRUE(service()->IsSyncActive());
   EXPECT_EQ(l10n_util::GetStringUTF16(IDS_SYNC_TIME_JUST_NOW),
             service()->GetLastSyncedTimeString());
   EXPECT_TRUE(service()->GetLocalDeviceInfoProvider()->GetLocalDeviceInfo());
 
   // Sign out.
   service()->RequestStop(ProfileSyncService::CLEAR_DATA);
   PumpLoop();
 
@@ skipping 11 matching lines @@
 // Verify that no disable sync flag enables sync.
 TEST_F(ProfileSyncServiceTest, NoDisableSyncFlag) {
   EXPECT_TRUE(ProfileSyncService::IsSyncAllowedByFlag());
 }
 
 // Test Sync will stop after receive memory pressure
 TEST_F(ProfileSyncServiceTest, MemoryPressureRecording) {
   CreateService(ProfileSyncService::AUTO_START);
   IssueTestTokens();
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
-  ExpectSyncBackendHostCreation(1);
+  ExpectSyncEngineCreation(1);
   InitializeForNthSync();
 
   EXPECT_TRUE(service()->IsSyncActive());
   EXPECT_FALSE(prefs()->GetBoolean(syncer::prefs::kSyncSuppressStart));
 
   testing::Mock::VerifyAndClearExpectations(component_factory());
 
   syncer::SyncPrefs sync_prefs(service()->GetSyncClient()->GetPrefService());
 
   EXPECT_EQ(prefs()->GetInteger(syncer::prefs::kSyncMemoryPressureWarningCount),
@@ skipping 27 matching lines @@
 TEST_F(ProfileSyncServiceTest, OnLocalSetPassphraseEncryption) {
   base::test::ScopedFeatureList scoped_feature_list;
   scoped_feature_list.InitAndEnableFeature(
       switches::kSyncClearDataOnPassphraseEncryption);
   IssueTestTokens();
   CreateService(ProfileSyncService::AUTO_START);
 
   syncer::SyncManager::ClearServerDataCallback captured_callback;
   syncer::ConfigureReason configure_reason = syncer::CONFIGURE_REASON_UNKNOWN;
 
-  // Initialize sync, ensure that both DataTypeManager and SyncBackendHost are
+  // Initialize sync, ensure that both DataTypeManager and SyncEngine are
   // initialized and DTM::Configure is called with
   // CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE.
-  ExpectSyncBackendHostCreationCaptureClearServerData(&captured_callback);
+  ExpectSyncEngineCreationCaptureClearServerData(&captured_callback);
   ExpectDataTypeManagerCreation(
       1, GetRecordingConfigureCalledCallback(&configure_reason));
   InitializeForNthSync();
   EXPECT_TRUE(service()->IsSyncActive());
   testing::Mock::VerifyAndClearExpectations(component_factory());
   EXPECT_EQ(syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE, configure_reason);
   syncer::DataTypeManager::ConfigureResult result;
   result.status = syncer::DataTypeManager::OK;
   service()->OnConfigureDone(result);
 
   // Simulate user entering encryption passphrase. Ensure that catch up
   // configure cycle is started (DTM::Configure is called with
   // CONFIGURE_REASON_CATCH_UP).
   const syncer::SyncEncryptionHandler::NigoriState nigori_state;
   service()->OnLocalSetPassphraseEncryption(nigori_state);
   EXPECT_EQ(syncer::CONFIGURE_REASON_CATCH_UP, configure_reason);
   EXPECT_TRUE(captured_callback.is_null());
 
   // Simulate configure successful. Ensure that SBH::ClearServerData is called.
   service()->OnConfigureDone(result);
   EXPECT_FALSE(captured_callback.is_null());
 
   // Once SBH::ClearServerData finishes successfully ensure that sync is
   // restarted.
   configure_reason = syncer::CONFIGURE_REASON_UNKNOWN;
-  ExpectSyncBackendHostCreation(1);
+  ExpectSyncEngineCreation(1);
   ExpectDataTypeManagerCreation(
       1, GetRecordingConfigureCalledCallback(&configure_reason));
   captured_callback.Run();
   testing::Mock::VerifyAndClearExpectations(component_factory());
   EXPECT_EQ(syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE, configure_reason);
   service()->OnConfigureDone(result);
 }
 
 // Verify that if after OnLocalSetPassphraseEncryption catch up configure sync
 // cycle gets interrupted, it starts again after browser restart.
 TEST_F(ProfileSyncServiceTest,
        OnLocalSetPassphraseEncryption_RestartDuringCatchUp) {
   syncer::ConfigureReason configure_reason = syncer::CONFIGURE_REASON_UNKNOWN;
   base::test::ScopedFeatureList scoped_feature_list;
   scoped_feature_list.InitAndEnableFeature(
       switches::kSyncClearDataOnPassphraseEncryption);
   IssueTestTokens();
   CreateService(ProfileSyncService::AUTO_START);
-  ExpectSyncBackendHostCreation(1);
+  ExpectSyncEngineCreation(1);
   ExpectDataTypeManagerCreation(
       1, GetRecordingConfigureCalledCallback(&configure_reason));
   InitializeForNthSync();
   testing::Mock::VerifyAndClearExpectations(component_factory());
   EXPECT_EQ(syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE, configure_reason);
   syncer::DataTypeManager::ConfigureResult result;
   result.status = syncer::DataTypeManager::OK;
   service()->OnConfigureDone(result);
 
   // Simulate user entering encryption passphrase. Ensure Configure was called
   // but don't let it continue.
   const syncer::SyncEncryptionHandler::NigoriState nigori_state;
   service()->OnLocalSetPassphraseEncryption(nigori_state);
   EXPECT_EQ(syncer::CONFIGURE_REASON_CATCH_UP, configure_reason);
 
   // Simulate browser restart. First configuration is a regular one.
   service()->Shutdown();
   syncer::SyncManager::ClearServerDataCallback captured_callback;
-  ExpectSyncBackendHostCreationCaptureClearServerData(&captured_callback);
+  ExpectSyncEngineCreationCaptureClearServerData(&captured_callback);
   ExpectDataTypeManagerCreation(
       1, GetRecordingConfigureCalledCallback(&configure_reason));
   service()->RequestStart();
   testing::Mock::VerifyAndClearExpectations(component_factory());
   EXPECT_EQ(syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE, configure_reason);
   EXPECT_TRUE(captured_callback.is_null());
 
   // Simulate configure successful. This time it should be catch up.
   service()->OnConfigureDone(result);
   EXPECT_EQ(syncer::CONFIGURE_REASON_CATCH_UP, configure_reason);
   EXPECT_TRUE(captured_callback.is_null());
 
   // Simulate catch up configure successful. Ensure that SBH::ClearServerData is
   // called.
   service()->OnConfigureDone(result);
   EXPECT_FALSE(captured_callback.is_null());
 
-  ExpectSyncBackendHostCreation(1);
+  ExpectSyncEngineCreation(1);
   ExpectDataTypeManagerCreation(
       1, GetRecordingConfigureCalledCallback(&configure_reason));
   captured_callback.Run();
   testing::Mock::VerifyAndClearExpectations(component_factory());
   EXPECT_EQ(syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE, configure_reason);
 }
 
 // Verify that if after OnLocalSetPassphraseEncryption ClearServerData gets
 // interrupted, transition again from catch up sync cycle after browser restart.
 TEST_F(ProfileSyncServiceTest,
        OnLocalSetPassphraseEncryption_RestartDuringClearServerData) {
   syncer::SyncManager::ClearServerDataCallback captured_callback;
   syncer::ConfigureReason configure_reason = syncer::CONFIGURE_REASON_UNKNOWN;
   base::test::ScopedFeatureList scoped_feature_list;
   scoped_feature_list.InitAndEnableFeature(
       switches::kSyncClearDataOnPassphraseEncryption);
   IssueTestTokens();
   CreateService(ProfileSyncService::AUTO_START);
-  ExpectSyncBackendHostCreationCaptureClearServerData(&captured_callback);
+  ExpectSyncEngineCreationCaptureClearServerData(&captured_callback);
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
   InitializeForNthSync();
   testing::Mock::VerifyAndClearExpectations(component_factory());
 
   // Simulate user entering encryption passphrase.
   const syncer::SyncEncryptionHandler::NigoriState nigori_state;
   service()->OnLocalSetPassphraseEncryption(nigori_state);
   EXPECT_FALSE(captured_callback.is_null());
   captured_callback.Reset();
 
   // Simulate browser restart. First configuration is a regular one.
   service()->Shutdown();
-  ExpectSyncBackendHostCreationCaptureClearServerData(&captured_callback);
+  ExpectSyncEngineCreationCaptureClearServerData(&captured_callback);
   ExpectDataTypeManagerCreation(
       1, GetRecordingConfigureCalledCallback(&configure_reason));
   service()->RequestStart();
   testing::Mock::VerifyAndClearExpectations(component_factory());
   EXPECT_EQ(syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE, configure_reason);
   EXPECT_TRUE(captured_callback.is_null());
 
   // Simulate configure successful. This time it should be catch up.
   syncer::DataTypeManager::ConfigureResult result;
   result.status = syncer::DataTypeManager::OK;
   service()->OnConfigureDone(result);
   EXPECT_EQ(syncer::CONFIGURE_REASON_CATCH_UP, configure_reason);
   EXPECT_TRUE(captured_callback.is_null());
 
   // Simulate catch up configure successful. Ensure that SBH::ClearServerData is
   // called.
   service()->OnConfigureDone(result);
   EXPECT_FALSE(captured_callback.is_null());
 
-  ExpectSyncBackendHostCreation(1);
+  ExpectSyncEngineCreation(1);
   ExpectDataTypeManagerCreation(
       1, GetRecordingConfigureCalledCallback(&configure_reason));
   captured_callback.Run();
   testing::Mock::VerifyAndClearExpectations(component_factory());
   EXPECT_EQ(syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE, configure_reason);
 }
 
 // Test that the passphrase prompt due to version change logic gets triggered
 // on a datatype type requesting startup, but only happens once.
 TEST_F(ProfileSyncServiceTest, PassphrasePromptDueToVersion) {
   IssueTestTokens();
   CreateService(ProfileSyncService::AUTO_START);
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
-  ExpectSyncBackendHostCreation(1);
+  ExpectSyncEngineCreation(1);
   InitializeForNthSync();
 
   syncer::SyncPrefs sync_prefs(service()->GetSyncClient()->GetPrefService());
   EXPECT_EQ(PRODUCT_VERSION, sync_prefs.GetLastRunVersion());
 
   sync_prefs.SetPassphrasePrompted(true);
 
   // Until a datatype requests startup while a passphrase is required the
   // passphrase prompt bit should remain set.
   EXPECT_TRUE(sync_prefs.IsPassphrasePrompted());
@@ skipping 12 matching lines @@
 }
 
 // Test that when ProfileSyncService receives actionable error
 // RESET_LOCAL_SYNC_DATA it restarts sync.
 TEST_F(ProfileSyncServiceTest, ResetSyncData) {
   IssueTestTokens();
   CreateService(ProfileSyncService::AUTO_START);
   // Backend should get initialized two times: once during initialization and
   // once when handling actionable error.
   ExpectDataTypeManagerCreation(2, GetDefaultConfigureCalledCallback());
-  ExpectSyncBackendHostCreation(2);
+  ExpectSyncEngineCreation(2);
   InitializeForNthSync();
 
   syncer::SyncProtocolError client_cmd;
   client_cmd.action = syncer::RESET_LOCAL_SYNC_DATA;
   service()->OnActionableError(client_cmd);
 }
 
 // Test that when ProfileSyncService receives actionable error
 // DISABLE_SYNC_ON_CLIENT it disables sync and signs out.
 TEST_F(ProfileSyncServiceTest, DisableSyncOnClient) {
   IssueTestTokens();
   CreateService(ProfileSyncService::AUTO_START);
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
-  ExpectSyncBackendHostCreation(1);
+  ExpectSyncEngineCreation(1);
   InitializeForNthSync();
 
   EXPECT_TRUE(service()->IsSyncActive());
   EXPECT_EQ(l10n_util::GetStringUTF16(IDS_SYNC_TIME_JUST_NOW),
             service()->GetLastSyncedTimeString());
   EXPECT_TRUE(service()->GetLocalDeviceInfoProvider()->GetLocalDeviceInfo());
 
   syncer::SyncProtocolError client_cmd;
   client_cmd.action = syncer::DISABLE_SYNC_ON_CLIENT;
   service()->OnActionableError(client_cmd);
@@ skipping 32 matching lines @@
   // Progress the controller to RUNNING first, which is how the service
   // determines whether a type is enabled.
   controller->StartAssociating(base::Bind(&DoNothing));
   controller->FinishStart(DataTypeController::OK_FIRST_RUN);
   service()->RegisterDataTypeController(std::move(controller));
   EXPECT_NE(nullptr, service()->GetOpenTabsUIDelegate());
 }
 
 }  // namespace
 }  // namespace browser_sync