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