| OLD | NEW |
|---|
| (Empty) |
| 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 <memory> | |
| 6 #include <utility> | |
| 7 | |
| 8 #include "base/files/file_util.h" | |
| 9 #include "base/strings/utf_string_conversions.h" | |
| 10 #include "base/threading/thread_task_runner_handle.h" | |
| 11 #include "build/build_config.h" | |
| 12 #include "components/browser_sync/browser/profile_sync_service.h" | |
| 13 #include "components/browser_sync/browser/profile_sync_test_util.h" | |
| 14 #include "components/prefs/pref_service.h" | |
| 15 #include "components/signin/core/browser/account_tracker_service.h" | |
| 16 #include "components/signin/core/browser/fake_profile_oauth2_token_service.h" | |
| 17 #include "components/signin/core/browser/profile_oauth2_token_service.h" | |
| 18 #include "components/signin/core/browser/signin_manager.h" | |
| 19 #include "components/signin/core/common/signin_pref_names.h" | |
| 20 #include "components/sync/driver/data_type_manager.h" | |
| 21 #include "components/sync/driver/data_type_manager_mock.h" | |
| 22 #include "components/sync/driver/fake_data_type_controller.h" | |
| 23 #include "components/sync/driver/glue/sync_backend_host_mock.h" | |
| 24 #include "components/sync/driver/pref_names.h" | |
| 25 #include "components/sync/driver/sync_api_component_factory_mock.h" | |
| 26 #include "components/sync/driver/sync_prefs.h" | |
| 27 #include "components/sync/driver/sync_service_observer.h" | |
| 28 #include "components/syncable_prefs/pref_service_syncable.h" | |
| 29 #include "google_apis/gaia/gaia_auth_consumer.h" | |
| 30 #include "google_apis/gaia/gaia_constants.h" | |
| 31 #include "google_apis/gaia/oauth2_token_service.h" | |
| 32 #include "net/url_request/url_request_test_util.h" | |
| 33 #include "testing/gmock/include/gmock/gmock.h" | |
| 34 #include "testing/gtest/include/gtest/gtest.h" | |
| 35 | |
| 36 using browser_sync::SyncBackendHostMock; | |
| 37 using sync_driver::DataTypeManager; | |
| 38 using sync_driver::DataTypeManagerMock; | |
| 39 using testing::_; | |
| 40 using testing::AnyNumber; | |
| 41 using testing::DoAll; | |
| 42 using testing::Mock; | |
| 43 using testing::Return; | |
| 44 | |
| 45 namespace { | |
| 46 | |
| 47 const char kGaiaId[] = "12345"; | |
| 48 const char kEmail[] = "test_user@gmail.com"; | |
| 49 const char kDummyPassword[] = ""; | |
| 50 | |
| 51 class SyncServiceObserverMock : public sync_driver::SyncServiceObserver { | |
| 52 public: | |
| 53 SyncServiceObserverMock(); | |
| 54 virtual ~SyncServiceObserverMock(); | |
| 55 | |
| 56 MOCK_METHOD0(OnStateChanged, void()); | |
| 57 }; | |
| 58 | |
| 59 SyncServiceObserverMock::SyncServiceObserverMock() {} | |
| 60 | |
| 61 SyncServiceObserverMock::~SyncServiceObserverMock() {} | |
| 62 | |
| 63 } // namespace | |
| 64 | |
| 65 ACTION_P(InvokeOnConfigureStart, sync_service) { | |
| 66 sync_service->OnConfigureStart(); | |
| 67 } | |
| 68 | |
| 69 ACTION_P3(InvokeOnConfigureDone, sync_service, error_callback, result) { | |
| 70 DataTypeManager::ConfigureResult configure_result = | |
| 71 static_cast<DataTypeManager::ConfigureResult>(result); | |
| 72 if (result.status == sync_driver::DataTypeManager::ABORTED) | |
| 73 error_callback.Run(&configure_result); | |
| 74 sync_service->OnConfigureDone(configure_result); | |
| 75 } | |
| 76 | |
| 77 class ProfileSyncServiceStartupTest : public testing::Test { | |
| 78 public: | |
| 79 ProfileSyncServiceStartupTest() { | |
| 80 profile_sync_service_bundle_.auth_service() | |
| 81 ->set_auto_post_fetch_response_on_message_loop(true); | |
| 82 } | |
| 83 | |
| 84 ~ProfileSyncServiceStartupTest() override { | |
| 85 sync_service_->RemoveObserver(&observer_); | |
| 86 sync_service_->Shutdown(); | |
| 87 } | |
| 88 | |
| 89 void CreateSyncService( | |
| 90 ProfileSyncService::StartBehavior start_behavior) { | |
| 91 component_factory_ = profile_sync_service_bundle_.component_factory(); | |
| 92 browser_sync::ProfileSyncServiceBundle::SyncClientBuilder builder( | |
| 93 &profile_sync_service_bundle_); | |
| 94 ProfileSyncService::InitParams init_params = | |
| 95 profile_sync_service_bundle_.CreateBasicInitParams(start_behavior, | |
| 96 builder.Build()); | |
| 97 | |
| 98 sync_service_.reset(new ProfileSyncService(std::move(init_params))); | |
| 99 sync_service_->RegisterDataTypeController( | |
| 100 base::MakeUnique<sync_driver::FakeDataTypeController>( | |
| 101 syncer::BOOKMARKS)); | |
| 102 sync_service_->AddObserver(&observer_); | |
| 103 } | |
| 104 | |
| 105 void IssueTestTokens(const std::string& account_id) { | |
| 106 profile_sync_service_bundle_.auth_service()->UpdateCredentials( | |
| 107 account_id, "oauth2_login_token"); | |
| 108 } | |
| 109 | |
| 110 void SetError(DataTypeManager::ConfigureResult* result) { | |
| 111 sync_driver::DataTypeStatusTable::TypeErrorMap errors; | |
| 112 errors[syncer::BOOKMARKS] = | |
| 113 syncer::SyncError(FROM_HERE, | |
| 114 syncer::SyncError::UNRECOVERABLE_ERROR, | |
| 115 "Error", | |
| 116 syncer::BOOKMARKS); | |
| 117 result->data_type_status_table.UpdateFailedDataTypes(errors); | |
| 118 } | |
| 119 | |
| 120 protected: | |
| 121 std::string SimulateTestUserSignin(ProfileSyncService* sync_service) { | |
| 122 std::string account_id = | |
| 123 profile_sync_service_bundle_.account_tracker()->SeedAccountInfo(kGaiaId, | |
| 124 kEmail); | |
| 125 pref_service()->SetString(prefs::kGoogleServicesAccountId, account_id); | |
| 126 #if !defined(OS_CHROMEOS) | |
| 127 profile_sync_service_bundle_.signin_manager()->SignIn(kGaiaId, kEmail, | |
| 128 kDummyPassword); | |
| 129 #else | |
| 130 profile_sync_service_bundle_.signin_manager()->SetAuthenticatedAccountInfo( | |
| 131 kGaiaId, kEmail); | |
| 132 if (sync_service) | |
| 133 sync_service->GoogleSigninSucceeded(account_id, kEmail, kDummyPassword); | |
| 134 #endif | |
| 135 return account_id; | |
| 136 } | |
| 137 | |
| 138 DataTypeManagerMock* SetUpDataTypeManager() { | |
| 139 DataTypeManagerMock* data_type_manager = new DataTypeManagerMock(); | |
| 140 EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _)) | |
| 141 .WillOnce(Return(data_type_manager)); | |
| 142 return data_type_manager; | |
| 143 } | |
| 144 | |
| 145 browser_sync::SyncBackendHostMock* SetUpSyncBackendHost() { | |
| 146 browser_sync::SyncBackendHostMock* sync_backend_host = | |
| 147 new browser_sync::SyncBackendHostMock(); | |
| 148 EXPECT_CALL(*component_factory_, CreateSyncBackendHost(_, _, _, _)) | |
| 149 .WillOnce(Return(sync_backend_host)); | |
| 150 return sync_backend_host; | |
| 151 } | |
| 152 | |
| 153 PrefService* pref_service() { | |
| 154 return profile_sync_service_bundle_.pref_service(); | |
| 155 } | |
| 156 | |
| 157 base::MessageLoop message_loop_; | |
| 158 browser_sync::ProfileSyncServiceBundle profile_sync_service_bundle_; | |
| 159 std::unique_ptr<ProfileSyncService> sync_service_; | |
| 160 SyncServiceObserverMock observer_; | |
| 161 sync_driver::DataTypeStatusTable data_type_status_table_; | |
| 162 SyncApiComponentFactoryMock* component_factory_ = nullptr; | |
| 163 }; | |
| 164 | |
| 165 class ProfileSyncServiceStartupCrosTest : public ProfileSyncServiceStartupTest { | |
| 166 public: | |
| 167 ProfileSyncServiceStartupCrosTest() { | |
| 168 CreateSyncService(ProfileSyncService::AUTO_START); | |
| 169 SimulateTestUserSignin(nullptr); | |
| 170 EXPECT_TRUE( | |
| 171 profile_sync_service_bundle_.signin_manager()->IsAuthenticated()); | |
| 172 } | |
| 173 }; | |
| 174 | |
| 175 TEST_F(ProfileSyncServiceStartupTest, StartFirstTime) { | |
| 176 // We've never completed startup. | |
| 177 pref_service()->ClearPref(sync_driver::prefs::kSyncFirstSetupComplete); | |
| 178 CreateSyncService(ProfileSyncService::MANUAL_START); | |
| 179 SetUpSyncBackendHost(); | |
| 180 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | |
| 181 EXPECT_CALL(*data_type_manager, Configure(_, _)).Times(0); | |
| 182 | |
| 183 // Should not actually start, rather just clean things up and wait | |
| 184 // to be enabled. | |
| 185 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
| 186 sync_service_->Initialize(); | |
| 187 | |
| 188 // Preferences should be back to defaults. | |
| 189 EXPECT_EQ(0, | |
| 190 pref_service()->GetInt64(sync_driver::prefs::kSyncLastSyncedTime)); | |
| 191 EXPECT_FALSE( | |
| 192 pref_service()->GetBoolean(sync_driver::prefs::kSyncFirstSetupComplete)); | |
| 193 Mock::VerifyAndClearExpectations(data_type_manager); | |
| 194 | |
| 195 // Then start things up. | |
| 196 EXPECT_CALL(*data_type_manager, Configure(_, _)).Times(1); | |
| 197 EXPECT_CALL(*data_type_manager, state()). | |
| 198 WillOnce(Return(DataTypeManager::CONFIGURED)). | |
| 199 WillOnce(Return(DataTypeManager::CONFIGURED)); | |
| 200 EXPECT_CALL(*data_type_manager, Stop()).Times(1); | |
| 201 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
| 202 | |
| 203 auto sync_blocker = sync_service_->GetSetupInProgressHandle(); | |
| 204 | |
| 205 // Simulate successful signin as test_user. | |
| 206 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | |
| 207 // Create some tokens in the token service. | |
| 208 IssueTestTokens(account_id); | |
| 209 | |
| 210 // Simulate the UI telling sync it has finished setting up. | |
| 211 sync_blocker.reset(); | |
| 212 sync_service_->SetFirstSetupComplete(); | |
| 213 EXPECT_TRUE(sync_service_->IsSyncActive()); | |
| 214 } | |
| 215 | |
| 216 // TODO(pavely): Reenable test once android is switched to oauth2. | |
| 217 TEST_F(ProfileSyncServiceStartupTest, DISABLED_StartNoCredentials) { | |
| 218 // We've never completed startup. | |
| 219 pref_service()->ClearPref(sync_driver::prefs::kSyncFirstSetupComplete); | |
| 220 CreateSyncService(ProfileSyncService::MANUAL_START); | |
| 221 | |
| 222 // Should not actually start, rather just clean things up and wait | |
| 223 // to be enabled. | |
| 224 EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _)) | |
| 225 .Times(0); | |
| 226 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
| 227 sync_service_->Initialize(); | |
| 228 | |
| 229 // Preferences should be back to defaults. | |
| 230 EXPECT_EQ(0, | |
| 231 pref_service()->GetInt64(sync_driver::prefs::kSyncLastSyncedTime)); | |
| 232 EXPECT_FALSE( | |
| 233 pref_service()->GetBoolean(sync_driver::prefs::kSyncFirstSetupComplete)); | |
| 234 | |
| 235 // Then start things up. | |
| 236 auto sync_blocker = sync_service_->GetSetupInProgressHandle(); | |
| 237 | |
| 238 // Simulate successful signin as test_user. | |
| 239 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | |
| 240 | |
| 241 profile_sync_service_bundle_.auth_service()->LoadCredentials(account_id); | |
| 242 | |
| 243 sync_blocker.reset(); | |
| 244 // ProfileSyncService should try to start by requesting access token. | |
| 245 // This request should fail as login token was not issued. | |
| 246 EXPECT_FALSE(sync_service_->IsSyncActive()); | |
| 247 EXPECT_EQ(GoogleServiceAuthError::USER_NOT_SIGNED_UP, | |
| 248 sync_service_->GetAuthError().state()); | |
| 249 } | |
| 250 | |
| 251 // TODO(pavely): Reenable test once android is switched to oauth2. | |
| 252 TEST_F(ProfileSyncServiceStartupTest, DISABLED_StartInvalidCredentials) { | |
| 253 CreateSyncService(ProfileSyncService::MANUAL_START); | |
| 254 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | |
| 255 SyncBackendHostMock* mock_sbh = SetUpSyncBackendHost(); | |
| 256 | |
| 257 // Tell the backend to stall while downloading control types (simulating an | |
| 258 // auth error). | |
| 259 mock_sbh->set_fail_initial_download(true); | |
| 260 | |
| 261 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | |
| 262 EXPECT_CALL(*data_type_manager, Configure(_, _)).Times(0); | |
| 263 | |
| 264 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
| 265 sync_service_->Initialize(); | |
| 266 EXPECT_FALSE(sync_service_->IsSyncActive()); | |
| 267 Mock::VerifyAndClearExpectations(data_type_manager); | |
| 268 | |
| 269 // Update the credentials, unstalling the backend. | |
| 270 EXPECT_CALL(*data_type_manager, Configure(_, _)); | |
| 271 EXPECT_CALL(*data_type_manager, state()). | |
| 272 WillRepeatedly(Return(DataTypeManager::CONFIGURED)); | |
| 273 EXPECT_CALL(*data_type_manager, Stop()).Times(1); | |
| 274 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
| 275 auto sync_blocker = sync_service_->GetSetupInProgressHandle(); | |
| 276 | |
| 277 // Simulate successful signin. | |
| 278 SimulateTestUserSignin(sync_service_.get()); | |
| 279 | |
| 280 sync_blocker.reset(); | |
| 281 | |
| 282 // Verify we successfully finish startup and configuration. | |
| 283 EXPECT_TRUE(sync_service_->IsSyncActive()); | |
| 284 } | |
| 285 | |
| 286 TEST_F(ProfileSyncServiceStartupCrosTest, StartCrosNoCredentials) { | |
| 287 EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _)) | |
| 288 .Times(0); | |
| 289 EXPECT_CALL(*component_factory_, CreateSyncBackendHost(_, _, _, _)).Times(0); | |
| 290 pref_service()->ClearPref(sync_driver::prefs::kSyncFirstSetupComplete); | |
| 291 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
| 292 | |
| 293 sync_service_->Initialize(); | |
| 294 // Sync should not start because there are no tokens yet. | |
| 295 EXPECT_FALSE(sync_service_->IsSyncActive()); | |
| 296 sync_service_->SetFirstSetupComplete(); | |
| 297 | |
| 298 // Sync should not start because there are still no tokens. | |
| 299 EXPECT_FALSE(sync_service_->IsSyncActive()); | |
| 300 } | |
| 301 | |
| 302 TEST_F(ProfileSyncServiceStartupCrosTest, StartFirstTime) { | |
| 303 SetUpSyncBackendHost(); | |
| 304 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | |
| 305 pref_service()->ClearPref(sync_driver::prefs::kSyncFirstSetupComplete); | |
| 306 EXPECT_CALL(*data_type_manager, Configure(_, _)); | |
| 307 EXPECT_CALL(*data_type_manager, state()). | |
| 308 WillRepeatedly(Return(DataTypeManager::CONFIGURED)); | |
| 309 EXPECT_CALL(*data_type_manager, Stop()); | |
| 310 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
| 311 | |
| 312 IssueTestTokens( | |
| 313 profile_sync_service_bundle_.account_tracker()->PickAccountIdForAccount( | |
| 314 "12345", kEmail)); | |
| 315 sync_service_->Initialize(); | |
| 316 EXPECT_TRUE(sync_service_->IsSyncActive()); | |
| 317 } | |
| 318 | |
| 319 TEST_F(ProfileSyncServiceStartupTest, StartNormal) { | |
| 320 // Pre load the tokens | |
| 321 CreateSyncService(ProfileSyncService::MANUAL_START); | |
| 322 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | |
| 323 sync_service_->SetFirstSetupComplete(); | |
| 324 SetUpSyncBackendHost(); | |
| 325 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | |
| 326 EXPECT_CALL(*data_type_manager, Configure(_, _)); | |
| 327 EXPECT_CALL(*data_type_manager, state()). | |
| 328 WillRepeatedly(Return(DataTypeManager::CONFIGURED)); | |
| 329 EXPECT_CALL(*data_type_manager, Stop()).Times(1); | |
| 330 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
| 331 | |
| 332 IssueTestTokens(account_id); | |
| 333 | |
| 334 sync_service_->Initialize(); | |
| 335 } | |
| 336 | |
| 337 // Test that we can recover from a case where a bug in the code resulted in | |
| 338 // OnUserChoseDatatypes not being properly called and datatype preferences | |
| 339 // therefore being left unset. | |
| 340 TEST_F(ProfileSyncServiceStartupTest, StartRecoverDatatypePrefs) { | |
| 341 // Clear the datatype preference fields (simulating bug 154940). | |
| 342 pref_service()->ClearPref(sync_driver::prefs::kSyncKeepEverythingSynced); | |
| 343 syncer::ModelTypeSet user_types = syncer::UserTypes(); | |
| 344 for (syncer::ModelTypeSet::Iterator iter = user_types.First(); | |
| 345 iter.Good(); iter.Inc()) { | |
| 346 pref_service()->ClearPref( | |
| 347 sync_driver::SyncPrefs::GetPrefNameForDataType(iter.Get())); | |
| 348 } | |
| 349 | |
| 350 // Pre load the tokens | |
| 351 CreateSyncService(ProfileSyncService::MANUAL_START); | |
| 352 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | |
| 353 sync_service_->SetFirstSetupComplete(); | |
| 354 SetUpSyncBackendHost(); | |
| 355 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | |
| 356 EXPECT_CALL(*data_type_manager, Configure(_, _)); | |
| 357 EXPECT_CALL(*data_type_manager, state()). | |
| 358 WillRepeatedly(Return(DataTypeManager::CONFIGURED)); | |
| 359 EXPECT_CALL(*data_type_manager, Stop()).Times(1); | |
| 360 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
| 361 | |
| 362 IssueTestTokens(account_id); | |
| 363 sync_service_->Initialize(); | |
| 364 | |
| 365 EXPECT_TRUE(pref_service()->GetBoolean( | |
| 366 sync_driver::prefs::kSyncKeepEverythingSynced)); | |
| 367 } | |
| 368 | |
| 369 // Verify that the recovery of datatype preferences doesn't overwrite a valid | |
| 370 // case where only bookmarks are enabled. | |
| 371 TEST_F(ProfileSyncServiceStartupTest, StartDontRecoverDatatypePrefs) { | |
| 372 // Explicitly set Keep Everything Synced to false and have only bookmarks | |
| 373 // enabled. | |
| 374 pref_service()->SetBoolean(sync_driver::prefs::kSyncKeepEverythingSynced, | |
| 375 false); | |
| 376 | |
| 377 // Pre load the tokens | |
| 378 CreateSyncService(ProfileSyncService::MANUAL_START); | |
| 379 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | |
| 380 sync_service_->SetFirstSetupComplete(); | |
| 381 SetUpSyncBackendHost(); | |
| 382 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | |
| 383 EXPECT_CALL(*data_type_manager, Configure(_, _)); | |
| 384 EXPECT_CALL(*data_type_manager, state()). | |
| 385 WillRepeatedly(Return(DataTypeManager::CONFIGURED)); | |
| 386 EXPECT_CALL(*data_type_manager, Stop()).Times(1); | |
| 387 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
| 388 IssueTestTokens(account_id); | |
| 389 sync_service_->Initialize(); | |
| 390 | |
| 391 EXPECT_FALSE(pref_service()->GetBoolean( | |
| 392 sync_driver::prefs::kSyncKeepEverythingSynced)); | |
| 393 } | |
| 394 | |
| 395 TEST_F(ProfileSyncServiceStartupTest, ManagedStartup) { | |
| 396 // Service should not be started by Initialize() since it's managed. | |
| 397 pref_service()->SetString(prefs::kGoogleServicesAccountId, kEmail); | |
| 398 CreateSyncService(ProfileSyncService::MANUAL_START); | |
| 399 | |
| 400 // Disable sync through policy. | |
| 401 pref_service()->SetBoolean(sync_driver::prefs::kSyncManaged, true); | |
| 402 EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _)) | |
| 403 .Times(0); | |
| 404 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
| 405 | |
| 406 sync_service_->Initialize(); | |
| 407 } | |
| 408 | |
| 409 TEST_F(ProfileSyncServiceStartupTest, SwitchManaged) { | |
| 410 CreateSyncService(ProfileSyncService::MANUAL_START); | |
| 411 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | |
| 412 sync_service_->SetFirstSetupComplete(); | |
| 413 SetUpSyncBackendHost(); | |
| 414 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | |
| 415 EXPECT_CALL(*data_type_manager, Configure(_, _)); | |
| 416 EXPECT_CALL(*data_type_manager, state()) | |
| 417 .WillRepeatedly(Return(DataTypeManager::CONFIGURED)); | |
| 418 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
| 419 IssueTestTokens(account_id); | |
| 420 sync_service_->Initialize(); | |
| 421 EXPECT_TRUE(sync_service_->IsBackendInitialized()); | |
| 422 EXPECT_TRUE(sync_service_->IsSyncActive()); | |
| 423 | |
| 424 // The service should stop when switching to managed mode. | |
| 425 Mock::VerifyAndClearExpectations(data_type_manager); | |
| 426 EXPECT_CALL(*data_type_manager, state()). | |
| 427 WillOnce(Return(DataTypeManager::CONFIGURED)); | |
| 428 EXPECT_CALL(*data_type_manager, Stop()).Times(1); | |
| 429 pref_service()->SetBoolean(sync_driver::prefs::kSyncManaged, true); | |
| 430 EXPECT_FALSE(sync_service_->IsBackendInitialized()); | |
| 431 // Note that PSS no longer references |data_type_manager| after stopping. | |
| 432 | |
| 433 // When switching back to unmanaged, the state should change but sync should | |
| 434 // not start automatically because IsFirstSetupComplete() will be false. | |
| 435 // A new DataTypeManager should not be created. | |
| 436 Mock::VerifyAndClearExpectations(data_type_manager); | |
| 437 EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _)) | |
| 438 .Times(0); | |
| 439 pref_service()->ClearPref(sync_driver::prefs::kSyncManaged); | |
| 440 EXPECT_FALSE(sync_service_->IsBackendInitialized()); | |
| 441 EXPECT_FALSE(sync_service_->IsSyncActive()); | |
| 442 } | |
| 443 | |
| 444 TEST_F(ProfileSyncServiceStartupTest, StartFailure) { | |
| 445 CreateSyncService(ProfileSyncService::MANUAL_START); | |
| 446 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | |
| 447 sync_service_->SetFirstSetupComplete(); | |
| 448 SetUpSyncBackendHost(); | |
| 449 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | |
| 450 DataTypeManager::ConfigureStatus status = DataTypeManager::ABORTED; | |
| 451 DataTypeManager::ConfigureResult result( | |
| 452 status, | |
| 453 syncer::ModelTypeSet()); | |
| 454 EXPECT_CALL(*data_type_manager, Configure(_, _)) | |
| 455 .WillRepeatedly( | |
| 456 DoAll(InvokeOnConfigureStart(sync_service_.get()), | |
| 457 InvokeOnConfigureDone( | |
| 458 sync_service_.get(), | |
| 459 base::Bind(&ProfileSyncServiceStartupTest::SetError, | |
| 460 base::Unretained(this)), | |
| 461 result))); | |
| 462 EXPECT_CALL(*data_type_manager, state()). | |
| 463 WillOnce(Return(DataTypeManager::STOPPED)); | |
| 464 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
| 465 IssueTestTokens(account_id); | |
| 466 sync_service_->Initialize(); | |
| 467 EXPECT_TRUE(sync_service_->HasUnrecoverableError()); | |
| 468 } | |
| 469 | |
| 470 TEST_F(ProfileSyncServiceStartupTest, StartDownloadFailed) { | |
| 471 // Pre load the tokens | |
| 472 CreateSyncService(ProfileSyncService::MANUAL_START); | |
| 473 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | |
| 474 SyncBackendHostMock* mock_sbh = SetUpSyncBackendHost(); | |
| 475 mock_sbh->set_fail_initial_download(true); | |
| 476 | |
| 477 pref_service()->ClearPref(sync_driver::prefs::kSyncFirstSetupComplete); | |
| 478 | |
| 479 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | |
| 480 sync_service_->Initialize(); | |
| 481 | |
| 482 auto sync_blocker = sync_service_->GetSetupInProgressHandle(); | |
| 483 IssueTestTokens(account_id); | |
| 484 sync_blocker.reset(); | |
| 485 EXPECT_FALSE(sync_service_->IsSyncActive()); | |
| 486 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2345843003:
[Sync] Merge //components/browser_sync into one directory. (Closed)
