src/chrome/browser/sync/profile_sync_service_startup_unittest.cc

   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@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@gmail.com");
 133 #if !defined(OS_CHROMEOS)
 134     fake_signin()->SignIn("test_user@gmail.com", "");
 135 #else
 136     fake_signin()->SetAuthenticatedUsername("test_user@gmail.com");
 137     sync_->GoogleSigninSucceeded("test_user@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@gmail.com");
 181     signin->SetAuthenticatedUsername("test_user@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@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@gmail.com");
 277   sync_->signin()->SetAuthenticatedUsername("test_user@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@gmail.com");
 346   SigninManagerFactory::GetForProfile(profile_)
 347       ->SetAuthenticatedUsername("test_user@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@gmail.com");
 380   SigninManagerFactory::GetForProfile(profile_)
 381       ->SetAuthenticatedUsername("test_user@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@gmail.com");
 410   SigninManagerFactory::GetForProfile(profile_)
 411       ->SetAuthenticatedUsername("test_user@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@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@gmail.com");
 446   SigninManagerFactory::GetForProfile(profile_)
 447       ->SetAuthenticatedUsername("test_user@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@gmail.com");
 477   SigninManagerFactory::GetForProfile(profile_)
 478       ->SetAuthenticatedUsername("test_user@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@gmail.com");
 513   SigninManagerFactory::GetForProfile(profile_)
 514       ->SetAuthenticatedUsername("test_user@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 }