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