1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "base/file_util.h" 6 #include "base/memory/scoped_ptr.h" 7 #include "base/prefs/pref_service.h" 8 #include "base/strings/utf_string_conversions.h" 9 #include "chrome/browser/prefs/pref_service_syncable.h" 10 #include "chrome/browser/signin/fake_profile_oauth2_token_service.h" 11 #include "chrome/browser/signin/fake_profile_oauth2_token_service_builder.h" 12 #include "chrome/browser/signin/fake_signin_manager.h" 13 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h" 14 #include "chrome/browser/signin/signin_manager_factory.h" 15 #include "chrome/browser/sync/glue/sync_backend_host_mock.h" 16 #include "chrome/browser/sync/managed_user_signin_manager_wrapper.h" 17 #include "chrome/browser/sync/profile_sync_components_factory_mock.h" 18 #include "chrome/browser/sync/profile_sync_service_factory.h" 19 #include "chrome/browser/sync/profile_sync_test_util.h" 20 #include "chrome/common/pref_names.h" 21 #include "chrome/test/base/testing_browser_process.h" 22 #include "chrome/test/base/testing_profile.h" 23 #include "chrome/test/base/testing_profile_manager.h" 24 #include "components/signin/core/browser/profile_oauth2_token_service.h" 25 #include "components/signin/core/browser/signin_manager.h" 26 #include "components/sync_driver/data_type_manager.h" 27 #include "components/sync_driver/data_type_manager_mock.h" 28 #include "components/sync_driver/pref_names.h" 29 #include "components/sync_driver/sync_prefs.h" 30 #include "content/public/test/test_browser_thread_bundle.h" 31 #include "content/public/test/test_utils.h" 32 #include "google_apis/gaia/gaia_auth_consumer.h" 33 #include "google_apis/gaia/gaia_constants.h" 34 #include "google_apis/gaia/oauth2_token_service.h" 35 #include "testing/gmock/include/gmock/gmock.h" 36 #include "testing/gtest/include/gtest/gtest.h" 37 38 using browser_sync::DataTypeManager; 39 using browser_sync::DataTypeManagerMock; 40 using browser_sync::SyncBackendHostMock; 41 using content::BrowserThread; 42 using testing::_; 43 using testing::AnyNumber; 44 using testing::DoAll; 45 using testing::InvokeArgument; 46 using testing::Mock; 47 using testing::Return; 48 49 ACTION_P(InvokeOnConfigureStart, pss) { 50 ProfileSyncService* service = 51 static_cast<ProfileSyncService*>(pss); 52 service->OnConfigureStart(); 53 } 54 55 ACTION_P2(InvokeOnConfigureDone, pss, result) { 56 ProfileSyncService* service = 57 static_cast<ProfileSyncService*>(pss); 58 DataTypeManager::ConfigureResult configure_result = 59 static_cast<DataTypeManager::ConfigureResult>(result); 60 service->OnConfigureDone(configure_result); 61 } 62 63 class ProfileSyncServiceStartupTest : public testing::Test { 64 public: 65 ProfileSyncServiceStartupTest() 66 : thread_bundle_(content::TestBrowserThreadBundle::REAL_DB_THREAD | 67 content::TestBrowserThreadBundle::REAL_FILE_THREAD | 68 content::TestBrowserThreadBundle::REAL_IO_THREAD), 69 profile_manager_(TestingBrowserProcess::GetGlobal()), 70 sync_(NULL) {} 71 72 virtual ~ProfileSyncServiceStartupTest() { 73 } 74 75 virtual void SetUp() { 76 CHECK(profile_manager_.SetUp()); 77 78 TestingProfile::TestingFactories testing_facotries; 79 testing_facotries.push_back( 80 std::make_pair(SigninManagerFactory::GetInstance(), 81 FakeSigninManagerBase::Build)); 82 testing_facotries.push_back( 83 std::make_pair(ProfileOAuth2TokenServiceFactory::GetInstance(), 84 BuildAutoIssuingFakeProfileOAuth2TokenService)); 85 testing_facotries.push_back( 86 std::make_pair(ProfileSyncServiceFactory::GetInstance(), 87 BuildService)); 88 89 profile_ = profile_manager_.CreateTestingProfile( 90 "sync-startup-test", scoped_ptr<PrefServiceSyncable>(), 91 base::UTF8ToUTF16("sync-startup-test"), 0, std::string(), 92 testing_facotries); 93 } 94 95 virtual void TearDown() { 96 sync_->RemoveObserver(&observer_); 97 } 98 99 static KeyedService* BuildService(content::BrowserContext* browser_context) { 100 Profile* profile = static_cast<Profile*>(browser_context); 101 return new ProfileSyncService( 102 new ProfileSyncComponentsFactoryMock(), 103 profile, 104 make_scoped_ptr(new ManagedUserSigninManagerWrapper( 105 profile, SigninManagerFactory::GetForProfile(profile))), 106 ProfileOAuth2TokenServiceFactory::GetForProfile(profile), 107 browser_sync::MANUAL_START); 108 } 109 110 void CreateSyncService() { 111 sync_ = static_cast<ProfileSyncService*>( 112 ProfileSyncServiceFactory::GetForProfile(profile_)); 113 sync_->AddObserver(&observer_); 114 } 115 116 void IssueTestTokens() { 117 ProfileOAuth2TokenServiceFactory::GetForProfile(profile_) 118 ->UpdateCredentials("test_user (at) gmail.com", "oauth2_login_token"); 119 } 120 121 ProfileSyncComponentsFactoryMock* components_factory_mock() { 122 return static_cast<ProfileSyncComponentsFactoryMock*>(sync_->factory()); 123 } 124 125 FakeSigninManagerForTesting* fake_signin() { 126 return static_cast<FakeSigninManagerForTesting*>(sync_->signin()); 127 } 128 129 protected: 130 void SimulateTestUserSignin() { 131 profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername, 132 "test_user (at) gmail.com"); 133 #if !defined(OS_CHROMEOS) 134 fake_signin()->SignIn("test_user (at) gmail.com", ""); 135 #else 136 fake_signin()->SetAuthenticatedUsername("test_user (at) gmail.com"); 137 sync_->GoogleSigninSucceeded("test_user (at) gmail.com", ""); 138 #endif 139 } 140 141 DataTypeManagerMock* SetUpDataTypeManager() { 142 DataTypeManagerMock* data_type_manager = new DataTypeManagerMock(); 143 EXPECT_CALL(*components_factory_mock(), 144 CreateDataTypeManager(_, _, _, _, _, _)). 145 WillOnce(Return(data_type_manager)); 146 return data_type_manager; 147 } 148 149 browser_sync::SyncBackendHostMock* SetUpSyncBackendHost() { 150 browser_sync::SyncBackendHostMock* sync_backend_host = 151 new browser_sync::SyncBackendHostMock(); 152 EXPECT_CALL(*components_factory_mock(), 153 CreateSyncBackendHost(_, _, _, _, _)). 154 WillOnce(Return(sync_backend_host)); 155 return sync_backend_host; 156 } 157 158 content::TestBrowserThreadBundle thread_bundle_; 159 TestingProfileManager profile_manager_; 160 TestingProfile* profile_; 161 ProfileSyncService* sync_; 162 ProfileSyncServiceObserverMock observer_; 163 }; 164 165 class ProfileSyncServiceStartupCrosTest : public ProfileSyncServiceStartupTest { 166 public: 167 virtual void SetUp() { 168 ProfileSyncServiceStartupTest::SetUp(); 169 sync_ = static_cast<ProfileSyncService*>( 170 ProfileSyncServiceFactory::GetInstance()->SetTestingFactoryAndUse( 171 profile_, BuildCrosService)); 172 sync_->AddObserver(&observer_); 173 } 174 175 static KeyedService* BuildCrosService(content::BrowserContext* context) { 176 Profile* profile = static_cast<Profile*>(context); 177 SigninManagerBase* signin = 178 SigninManagerFactory::GetForProfile(profile); 179 profile->GetPrefs()->SetString(prefs::kGoogleServicesUsername, 180 "test_user (at) gmail.com"); 181 signin->SetAuthenticatedUsername("test_user (at) gmail.com"); 182 ProfileOAuth2TokenService* oauth2_token_service = 183 ProfileOAuth2TokenServiceFactory::GetForProfile(profile); 184 EXPECT_FALSE(signin->GetAuthenticatedUsername().empty()); 185 return new ProfileSyncService( 186 new ProfileSyncComponentsFactoryMock(), 187 profile, 188 make_scoped_ptr(new ManagedUserSigninManagerWrapper(profile, signin)), 189 oauth2_token_service, 190 browser_sync::AUTO_START); 191 } 192 }; 193 194 TEST_F(ProfileSyncServiceStartupTest, StartFirstTime) { 195 // We've never completed startup. 196 profile_->GetPrefs()->ClearPref(sync_driver::prefs::kSyncHasSetupCompleted); 197 CreateSyncService(); 198 SetUpSyncBackendHost(); 199 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); 200 EXPECT_CALL(*data_type_manager, Configure(_, _)).Times(0); 201 202 // Should not actually start, rather just clean things up and wait 203 // to be enabled. 204 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); 205 sync_->Initialize(); 206 207 // Preferences should be back to defaults. 208 EXPECT_EQ( 209 0, 210 profile_->GetPrefs()->GetInt64(sync_driver::prefs::kSyncLastSyncedTime)); 211 EXPECT_FALSE(profile_->GetPrefs()->GetBoolean( 212 sync_driver::prefs::kSyncHasSetupCompleted)); 213 Mock::VerifyAndClearExpectations(data_type_manager); 214 215 // Then start things up. 216 EXPECT_CALL(*data_type_manager, Configure(_, _)).Times(1); 217 EXPECT_CALL(*data_type_manager, state()). 218 WillOnce(Return(DataTypeManager::CONFIGURED)). 219 WillOnce(Return(DataTypeManager::CONFIGURED)); 220 EXPECT_CALL(*data_type_manager, Stop()).Times(1); 221 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); 222 223 sync_->SetSetupInProgress(true); 224 225 // Simulate successful signin as test_user. 226 SimulateTestUserSignin(); 227 // Create some tokens in the token service. 228 IssueTestTokens(); 229 230 // Simulate the UI telling sync it has finished setting up. 231 sync_->SetSetupInProgress(false); 232 EXPECT_TRUE(sync_->ShouldPushChanges()); 233 } 234 235 // TODO(pavely): Reenable test once android is switched to oauth2. 236 TEST_F(ProfileSyncServiceStartupTest, DISABLED_StartNoCredentials) { 237 // We've never completed startup. 238 profile_->GetPrefs()->ClearPref(sync_driver::prefs::kSyncHasSetupCompleted); 239 CreateSyncService(); 240 241 // Should not actually start, rather just clean things up and wait 242 // to be enabled. 243 EXPECT_CALL(*components_factory_mock(), 244 CreateDataTypeManager(_, _, _, _, _, _)).Times(0); 245 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); 246 sync_->Initialize(); 247 248 // Preferences should be back to defaults. 249 EXPECT_EQ( 250 0, 251 profile_->GetPrefs()->GetInt64(sync_driver::prefs::kSyncLastSyncedTime)); 252 EXPECT_FALSE(profile_->GetPrefs()->GetBoolean( 253 sync_driver::prefs::kSyncHasSetupCompleted)); 254 255 // Then start things up. 256 sync_->SetSetupInProgress(true); 257 258 // Simulate successful signin as test_user. 259 SimulateTestUserSignin(); 260 261 ProfileOAuth2TokenService* token_service = 262 ProfileOAuth2TokenServiceFactory::GetForProfile(profile_); 263 token_service->LoadCredentials("test_user (at) gmail.com"); 264 265 sync_->SetSetupInProgress(false); 266 // ProfileSyncService should try to start by requesting access token. 267 // This request should fail as login token was not issued. 268 EXPECT_FALSE(sync_->ShouldPushChanges()); 269 EXPECT_EQ(GoogleServiceAuthError::USER_NOT_SIGNED_UP, 270 sync_->GetAuthError().state()); 271 } 272 273 // TODO(pavely): Reenable test once android is switched to oauth2. 274 TEST_F(ProfileSyncServiceStartupTest, DISABLED_StartInvalidCredentials) { 275 profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername, 276 "test_user (at) gmail.com"); 277 sync_->signin()->SetAuthenticatedUsername("test_user (at) gmail.com"); 278 CreateSyncService(); 279 SyncBackendHostMock* mock_sbh = SetUpSyncBackendHost(); 280 281 // Tell the backend to stall while downloading control types (simulating an 282 // auth error). 283 mock_sbh->set_fail_initial_download(true); 284 285 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); 286 EXPECT_CALL(*data_type_manager, Configure(_, _)).Times(0); 287 288 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); 289 sync_->Initialize(); 290 EXPECT_FALSE(sync_->sync_initialized()); 291 Mock::VerifyAndClearExpectations(data_type_manager); 292 293 // Update the credentials, unstalling the backend. 294 EXPECT_CALL(*data_type_manager, Configure(_, _)); 295 EXPECT_CALL(*data_type_manager, state()). 296 WillRepeatedly(Return(DataTypeManager::CONFIGURED)); 297 EXPECT_CALL(*data_type_manager, Stop()).Times(1); 298 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); 299 sync_->SetSetupInProgress(true); 300 301 // Simulate successful signin. 302 SimulateTestUserSignin(); 303 304 sync_->SetSetupInProgress(false); 305 306 // Verify we successfully finish startup and configuration. 307 EXPECT_TRUE(sync_->ShouldPushChanges()); 308 } 309 310 TEST_F(ProfileSyncServiceStartupCrosTest, StartCrosNoCredentials) { 311 EXPECT_CALL(*components_factory_mock(), 312 CreateDataTypeManager(_, _, _, _, _, _)).Times(0); 313 EXPECT_CALL(*components_factory_mock(), 314 CreateSyncBackendHost(_, _, _, _, _)).Times(0); 315 profile_->GetPrefs()->ClearPref(sync_driver::prefs::kSyncHasSetupCompleted); 316 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); 317 318 sync_->Initialize(); 319 // Sync should not start because there are no tokens yet. 320 EXPECT_FALSE(sync_->ShouldPushChanges()); 321 sync_->SetSetupInProgress(false); 322 323 // Sync should not start because there are still no tokens. 324 EXPECT_FALSE(sync_->ShouldPushChanges()); 325 } 326 327 TEST_F(ProfileSyncServiceStartupCrosTest, StartFirstTime) { 328 SetUpSyncBackendHost(); 329 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); 330 profile_->GetPrefs()->ClearPref(sync_driver::prefs::kSyncHasSetupCompleted); 331 EXPECT_CALL(*data_type_manager, Configure(_, _)); 332 EXPECT_CALL(*data_type_manager, state()). 333 WillRepeatedly(Return(DataTypeManager::CONFIGURED)); 334 EXPECT_CALL(*data_type_manager, Stop()).Times(1); 335 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); 336 337 IssueTestTokens(); 338 sync_->Initialize(); 339 EXPECT_TRUE(sync_->ShouldPushChanges()); 340 } 341 342 TEST_F(ProfileSyncServiceStartupTest, StartNormal) { 343 // Pre load the tokens 344 profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername, 345 "test_user (at) gmail.com"); 346 SigninManagerFactory::GetForProfile(profile_) 347 ->SetAuthenticatedUsername("test_user (at) gmail.com"); 348 CreateSyncService(); 349 sync_->SetSyncSetupCompleted(); 350 SetUpSyncBackendHost(); 351 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); 352 EXPECT_CALL(*data_type_manager, Configure(_, _)); 353 EXPECT_CALL(*data_type_manager, state()). 354 WillRepeatedly(Return(DataTypeManager::CONFIGURED)); 355 EXPECT_CALL(*data_type_manager, Stop()).Times(1); 356 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); 357 358 IssueTestTokens(); 359 360 sync_->Initialize(); 361 } 362 363 // Test that we can recover from a case where a bug in the code resulted in 364 // OnUserChoseDatatypes not being properly called and datatype preferences 365 // therefore being left unset. 366 TEST_F(ProfileSyncServiceStartupTest, StartRecoverDatatypePrefs) { 367 // Clear the datatype preference fields (simulating bug 154940). 368 profile_->GetPrefs()->ClearPref( 369 sync_driver::prefs::kSyncKeepEverythingSynced); 370 syncer::ModelTypeSet user_types = syncer::UserTypes(); 371 for (syncer::ModelTypeSet::Iterator iter = user_types.First(); 372 iter.Good(); iter.Inc()) { 373 profile_->GetPrefs()->ClearPref( 374 sync_driver::SyncPrefs::GetPrefNameForDataType(iter.Get())); 375 } 376 377 // Pre load the tokens 378 profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername, 379 "test_user (at) gmail.com"); 380 SigninManagerFactory::GetForProfile(profile_) 381 ->SetAuthenticatedUsername("test_user (at) gmail.com"); 382 CreateSyncService(); 383 sync_->SetSyncSetupCompleted(); 384 SetUpSyncBackendHost(); 385 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); 386 EXPECT_CALL(*data_type_manager, Configure(_, _)); 387 EXPECT_CALL(*data_type_manager, state()). 388 WillRepeatedly(Return(DataTypeManager::CONFIGURED)); 389 EXPECT_CALL(*data_type_manager, Stop()).Times(1); 390 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); 391 392 IssueTestTokens(); 393 sync_->Initialize(); 394 395 EXPECT_TRUE(profile_->GetPrefs()->GetBoolean( 396 sync_driver::prefs::kSyncKeepEverythingSynced)); 397 } 398 399 // Verify that the recovery of datatype preferences doesn't overwrite a valid 400 // case where only bookmarks are enabled. 401 TEST_F(ProfileSyncServiceStartupTest, StartDontRecoverDatatypePrefs) { 402 // Explicitly set Keep Everything Synced to false and have only bookmarks 403 // enabled. 404 profile_->GetPrefs()->SetBoolean( 405 sync_driver::prefs::kSyncKeepEverythingSynced, false); 406 407 // Pre load the tokens 408 profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername, 409 "test_user (at) gmail.com"); 410 SigninManagerFactory::GetForProfile(profile_) 411 ->SetAuthenticatedUsername("test_user (at) gmail.com"); 412 CreateSyncService(); 413 sync_->SetSyncSetupCompleted(); 414 SetUpSyncBackendHost(); 415 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); 416 EXPECT_CALL(*data_type_manager, Configure(_, _)); 417 EXPECT_CALL(*data_type_manager, state()). 418 WillRepeatedly(Return(DataTypeManager::CONFIGURED)); 419 EXPECT_CALL(*data_type_manager, Stop()).Times(1); 420 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); 421 IssueTestTokens(); 422 sync_->Initialize(); 423 424 EXPECT_FALSE(profile_->GetPrefs()->GetBoolean( 425 sync_driver::prefs::kSyncKeepEverythingSynced)); 426 } 427 428 TEST_F(ProfileSyncServiceStartupTest, ManagedStartup) { 429 // Service should not be started by Initialize() since it's managed. 430 profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername, 431 "test_user (at) gmail.com"); 432 CreateSyncService(); 433 434 // Disable sync through policy. 435 profile_->GetPrefs()->SetBoolean(sync_driver::prefs::kSyncManaged, true); 436 EXPECT_CALL(*components_factory_mock(), 437 CreateDataTypeManager(_, _, _, _, _, _)).Times(0); 438 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); 439 440 sync_->Initialize(); 441 } 442 443 TEST_F(ProfileSyncServiceStartupTest, SwitchManaged) { 444 profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername, 445 "test_user (at) gmail.com"); 446 SigninManagerFactory::GetForProfile(profile_) 447 ->SetAuthenticatedUsername("test_user (at) gmail.com"); 448 CreateSyncService(); 449 sync_->SetSyncSetupCompleted(); 450 SetUpSyncBackendHost(); 451 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); 452 EXPECT_CALL(*data_type_manager, Configure(_, _)); 453 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); 454 IssueTestTokens(); 455 sync_->Initialize(); 456 457 // The service should stop when switching to managed mode. 458 Mock::VerifyAndClearExpectations(data_type_manager); 459 EXPECT_CALL(*data_type_manager, state()). 460 WillOnce(Return(DataTypeManager::CONFIGURED)); 461 EXPECT_CALL(*data_type_manager, Stop()).Times(1); 462 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); 463 profile_->GetPrefs()->SetBoolean(sync_driver::prefs::kSyncManaged, true); 464 465 // When switching back to unmanaged, the state should change, but the service 466 // should not start up automatically (kSyncSetupCompleted will be false). 467 Mock::VerifyAndClearExpectations(data_type_manager); 468 EXPECT_CALL(*components_factory_mock(), 469 CreateDataTypeManager(_, _, _, _, _, _)).Times(0); 470 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); 471 profile_->GetPrefs()->ClearPref(sync_driver::prefs::kSyncManaged); 472 } 473 474 TEST_F(ProfileSyncServiceStartupTest, StartFailure) { 475 profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername, 476 "test_user (at) gmail.com"); 477 SigninManagerFactory::GetForProfile(profile_) 478 ->SetAuthenticatedUsername("test_user (at) gmail.com"); 479 CreateSyncService(); 480 sync_->SetSyncSetupCompleted(); 481 SetUpSyncBackendHost(); 482 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); 483 DataTypeManager::ConfigureStatus status = DataTypeManager::ABORTED; 484 syncer::SyncError error( 485 FROM_HERE, 486 syncer::SyncError::DATATYPE_ERROR, 487 "Association failed.", 488 syncer::BOOKMARKS); 489 std::map<syncer::ModelType, syncer::SyncError> errors; 490 errors[syncer::BOOKMARKS] = error; 491 DataTypeManager::ConfigureResult result( 492 status, 493 syncer::ModelTypeSet(), 494 errors, 495 syncer::ModelTypeSet(), 496 syncer::ModelTypeSet()); 497 EXPECT_CALL(*data_type_manager, Configure(_, _)). 498 WillRepeatedly( 499 DoAll(InvokeOnConfigureStart(sync_), 500 InvokeOnConfigureDone(sync_, result))); 501 EXPECT_CALL(*data_type_manager, state()). 502 WillOnce(Return(DataTypeManager::STOPPED)); 503 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); 504 IssueTestTokens(); 505 sync_->Initialize(); 506 EXPECT_TRUE(sync_->HasUnrecoverableError()); 507 } 508 509 TEST_F(ProfileSyncServiceStartupTest, StartDownloadFailed) { 510 // Pre load the tokens 511 profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername, 512 "test_user (at) gmail.com"); 513 SigninManagerFactory::GetForProfile(profile_) 514 ->SetAuthenticatedUsername("test_user (at) gmail.com"); 515 CreateSyncService(); 516 SyncBackendHostMock* mock_sbh = SetUpSyncBackendHost(); 517 mock_sbh->set_fail_initial_download(true); 518 519 profile_->GetPrefs()->ClearPref(sync_driver::prefs::kSyncHasSetupCompleted); 520 521 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); 522 sync_->Initialize(); 523 524 sync_->SetSetupInProgress(true); 525 IssueTestTokens(); 526 sync_->SetSetupInProgress(false); 527 EXPECT_FALSE(sync_->sync_initialized()); 528 } 529