[Sync] SyncEngine refactor part 1: interfaces.

components/browser_sync/profile_sync_service_startup_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 "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/browser_sync/profile_sync_test_util.h"
 #include "components/prefs/pref_service.h"
 #include "components/signin/core/browser/account_tracker_service.h"
 #include "components/signin/core/browser/fake_profile_oauth2_token_service.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/signin/core/common/signin_pref_names.h"
 #include "components/sync/base/pref_names.h"
 #include "components/sync/driver/data_type_manager_mock.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_service_observer.h"
+#include "components/sync/engine/fake_sync_engine.h"
 #include "components/sync_preferences/pref_service_syncable.h"
 #include "google_apis/gaia/gaia_auth_consumer.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using syncer::DataTypeManager;
 using syncer::DataTypeManagerMock;
-using syncer::SyncBackendHostMock;
+using syncer::FakeSyncEngine;
 using testing::_;
 using testing::AnyNumber;
 using testing::DoAll;
 using testing::Mock;
 using testing::Return;
 
 namespace browser_sync {
 
 namespace {
 
@@ skipping 85 matching lines @@
     return account_id;
   }
 
   DataTypeManagerMock* SetUpDataTypeManager() {
     DataTypeManagerMock* data_type_manager = new DataTypeManagerMock();
     EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _))
         .WillOnce(Return(data_type_manager));
     return data_type_manager;
   }
 
-  SyncBackendHostMock* SetUpSyncBackendHost() {
-    SyncBackendHostMock* sync_backend_host = new SyncBackendHostMock();
-    EXPECT_CALL(*component_factory_, CreateSyncBackendHost(_, _, _, _))
+  FakeSyncEngine* SetUpSyncEngine() {
+    FakeSyncEngine* sync_backend_host = new FakeSyncEngine();
+    EXPECT_CALL(*component_factory_, CreateSyncEngine(_, _, _, _))
         .WillOnce(Return(sync_backend_host));
     return sync_backend_host;
   }
 
   PrefService* pref_service() {
     return profile_sync_service_bundle_.pref_service();
   }
 
   base::MessageLoop message_loop_;
   ProfileSyncServiceBundle profile_sync_service_bundle_;
@@ skipping 10 matching lines @@
     SimulateTestUserSignin(nullptr);
     EXPECT_TRUE(
         profile_sync_service_bundle_.signin_manager()->IsAuthenticated());
   }
 };
 
 TEST_F(ProfileSyncServiceStartupTest, StartFirstTime) {
   // We've never completed startup.
   pref_service()->ClearPref(syncer::prefs::kSyncFirstSetupComplete);
   CreateSyncService(ProfileSyncService::MANUAL_START);
-  SetUpSyncBackendHost();
+  SetUpSyncEngine();
   DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
   EXPECT_CALL(*data_type_manager, Configure(_, _)).Times(0);
 
   // Should not actually start, rather just clean things up and wait
   // to be enabled.
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   sync_service_->Initialize();
 
   // Preferences should be back to defaults.
   EXPECT_EQ(0, pref_service()->GetInt64(syncer::prefs::kSyncLastSyncedTime));
@@ skipping 53 matching lines @@
   // This request should fail as login token was not issued.
   EXPECT_FALSE(sync_service_->IsSyncActive());
   EXPECT_EQ(GoogleServiceAuthError::USER_NOT_SIGNED_UP,
             sync_service_->GetAuthError().state());
 }
 
 // TODO(pavely): Reenable test once android is switched to oauth2.
 TEST_F(ProfileSyncServiceStartupTest, DISABLED_StartInvalidCredentials) {
   CreateSyncService(ProfileSyncService::MANUAL_START);
   std::string account_id = SimulateTestUserSignin(sync_service_.get());
-  SyncBackendHostMock* mock_sbh = SetUpSyncBackendHost();
+  FakeSyncEngine* mock_sbh = SetUpSyncEngine();
 
   // Tell the backend to stall while downloading control types (simulating an
   // auth error).
   mock_sbh->set_fail_initial_download(true);
 
   DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
   EXPECT_CALL(*data_type_manager, Configure(_, _)).Times(0);
 
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   sync_service_->Initialize();
@@ skipping 13 matching lines @@
 
   sync_blocker.reset();
 
   // Verify we successfully finish startup and configuration.
   EXPECT_TRUE(sync_service_->IsSyncActive());
 }
 
 TEST_F(ProfileSyncServiceStartupCrosTest, StartCrosNoCredentials) {
   EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _))
       .Times(0);
-  EXPECT_CALL(*component_factory_, CreateSyncBackendHost(_, _, _, _)).Times(0);
+  EXPECT_CALL(*component_factory_, CreateSyncEngine(_, _, _, _)).Times(0);
   pref_service()->ClearPref(syncer::prefs::kSyncFirstSetupComplete);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
 
   sync_service_->Initialize();
   // Sync should not start because there are no tokens yet.
   EXPECT_FALSE(sync_service_->IsSyncActive());
   sync_service_->SetFirstSetupComplete();
 
   // Sync should not start because there are still no tokens.
   EXPECT_FALSE(sync_service_->IsSyncActive());
 }
 
 TEST_F(ProfileSyncServiceStartupCrosTest, StartFirstTime) {
-  SetUpSyncBackendHost();
+  SetUpSyncEngine();
   DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
   pref_service()->ClearPref(syncer::prefs::kSyncFirstSetupComplete);
   EXPECT_CALL(*data_type_manager, Configure(_, _));
   EXPECT_CALL(*data_type_manager, state())
       .WillRepeatedly(Return(DataTypeManager::CONFIGURED));
   EXPECT_CALL(*data_type_manager, Stop());
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
 
   IssueTestTokens(
       profile_sync_service_bundle_.account_tracker()->PickAccountIdForAccount(
           "12345", kEmail));
   sync_service_->Initialize();
   EXPECT_TRUE(sync_service_->IsSyncActive());
 }
 
 TEST_F(ProfileSyncServiceStartupTest, StartNormal) {
   // Pre load the tokens
   CreateSyncService(ProfileSyncService::MANUAL_START);
   std::string account_id = SimulateTestUserSignin(sync_service_.get());
   sync_service_->SetFirstSetupComplete();
-  SetUpSyncBackendHost();
+  SetUpSyncEngine();
   DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
   EXPECT_CALL(*data_type_manager, Configure(_, _));
   EXPECT_CALL(*data_type_manager, state())
       .WillRepeatedly(Return(DataTypeManager::CONFIGURED));
   EXPECT_CALL(*data_type_manager, Stop()).Times(1);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
 
   IssueTestTokens(account_id);
 
   sync_service_->Initialize();
 }
 
 // Test that we can recover from a case where a bug in the code resulted in
 // OnUserChoseDatatypes not being properly called and datatype preferences
 // therefore being left unset.
 TEST_F(ProfileSyncServiceStartupTest, StartRecoverDatatypePrefs) {
   // Clear the datatype preference fields (simulating bug 154940).
   pref_service()->ClearPref(syncer::prefs::kSyncKeepEverythingSynced);
   syncer::ModelTypeSet user_types = syncer::UserTypes();
   for (syncer::ModelTypeSet::Iterator iter = user_types.First(); iter.Good();
        iter.Inc()) {
     pref_service()->ClearPref(
         syncer::SyncPrefs::GetPrefNameForDataType(iter.Get()));
   }
 
   // Pre load the tokens
   CreateSyncService(ProfileSyncService::MANUAL_START);
   std::string account_id = SimulateTestUserSignin(sync_service_.get());
   sync_service_->SetFirstSetupComplete();
-  SetUpSyncBackendHost();
+  SetUpSyncEngine();
   DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
   EXPECT_CALL(*data_type_manager, Configure(_, _));
   EXPECT_CALL(*data_type_manager, state())
       .WillRepeatedly(Return(DataTypeManager::CONFIGURED));
   EXPECT_CALL(*data_type_manager, Stop()).Times(1);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
 
   IssueTestTokens(account_id);
   sync_service_->Initialize();
 
   EXPECT_TRUE(
       pref_service()->GetBoolean(syncer::prefs::kSyncKeepEverythingSynced));
 }
 
 // Verify that the recovery of datatype preferences doesn't overwrite a valid
 // case where only bookmarks are enabled.
 TEST_F(ProfileSyncServiceStartupTest, StartDontRecoverDatatypePrefs) {
   // Explicitly set Keep Everything Synced to false and have only bookmarks
   // enabled.
   pref_service()->SetBoolean(syncer::prefs::kSyncKeepEverythingSynced, false);
 
   // Pre load the tokens
   CreateSyncService(ProfileSyncService::MANUAL_START);
   std::string account_id = SimulateTestUserSignin(sync_service_.get());
   sync_service_->SetFirstSetupComplete();
-  SetUpSyncBackendHost();
+  SetUpSyncEngine();
   DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
   EXPECT_CALL(*data_type_manager, Configure(_, _));
   EXPECT_CALL(*data_type_manager, state())
       .WillRepeatedly(Return(DataTypeManager::CONFIGURED));
   EXPECT_CALL(*data_type_manager, Stop()).Times(1);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   IssueTestTokens(account_id);
   sync_service_->Initialize();
 
   EXPECT_FALSE(
@@ skipping 11 matching lines @@
       .Times(0);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
 
   sync_service_->Initialize();
 }
 
 TEST_F(ProfileSyncServiceStartupTest, SwitchManaged) {
   CreateSyncService(ProfileSyncService::MANUAL_START);
   std::string account_id = SimulateTestUserSignin(sync_service_.get());
   sync_service_->SetFirstSetupComplete();
-  SetUpSyncBackendHost();
+  SetUpSyncEngine();
   DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
   EXPECT_CALL(*data_type_manager, Configure(_, _));
   EXPECT_CALL(*data_type_manager, state())
       .WillRepeatedly(Return(DataTypeManager::CONFIGURED));
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   IssueTestTokens(account_id);
   sync_service_->Initialize();
   EXPECT_TRUE(sync_service_->IsBackendInitialized());
   EXPECT_TRUE(sync_service_->IsSyncActive());
 
@@ skipping 14 matching lines @@
       .Times(0);
   pref_service()->ClearPref(syncer::prefs::kSyncManaged);
   EXPECT_FALSE(sync_service_->IsBackendInitialized());
   EXPECT_FALSE(sync_service_->IsSyncActive());
 }
 
 TEST_F(ProfileSyncServiceStartupTest, StartFailure) {
   CreateSyncService(ProfileSyncService::MANUAL_START);
   std::string account_id = SimulateTestUserSignin(sync_service_.get());
   sync_service_->SetFirstSetupComplete();
-  SetUpSyncBackendHost();
+  SetUpSyncEngine();
   DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
   DataTypeManager::ConfigureStatus status = DataTypeManager::ABORTED;
   DataTypeManager::ConfigureResult result(status, syncer::ModelTypeSet());
   EXPECT_CALL(*data_type_manager, Configure(_, _))
       .WillRepeatedly(
           DoAll(InvokeOnConfigureStart(sync_service_.get()),
                 InvokeOnConfigureDone(
                     sync_service_.get(),
                     base::Bind(&ProfileSyncServiceStartupTest::SetError,
                                base::Unretained(this)),
                     result)));
   EXPECT_CALL(*data_type_manager, state())
       .WillOnce(Return(DataTypeManager::STOPPED));
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   IssueTestTokens(account_id);
   sync_service_->Initialize();
   EXPECT_TRUE(sync_service_->HasUnrecoverableError());
 }
 
 TEST_F(ProfileSyncServiceStartupTest, StartDownloadFailed) {
   // Pre load the tokens
   CreateSyncService(ProfileSyncService::MANUAL_START);
   std::string account_id = SimulateTestUserSignin(sync_service_.get());
-  SyncBackendHostMock* mock_sbh = SetUpSyncBackendHost();
+  FakeSyncEngine* mock_sbh = SetUpSyncEngine();
   mock_sbh->set_fail_initial_download(true);
 
   pref_service()->ClearPref(syncer::prefs::kSyncFirstSetupComplete);
 
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   sync_service_->Initialize();
 
   auto sync_blocker = sync_service_->GetSetupInProgressHandle();
   IssueTestTokens(account_id);
   sync_blocker.reset();
   EXPECT_FALSE(sync_service_->IsSyncActive());
 }
 
 }  // namespace browser_sync