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/basictypes.h" 6 #include "base/command_line.h" 7 #include "base/compiler_specific.h" 8 #include "base/memory/scoped_ptr.h" 9 #include "base/run_loop.h" 10 #include "base/strings/string_number_conversions.h" 11 #include "base/strings/utf_string_conversions.h" 12 #include "base/values.h" 13 #include "chrome/browser/invalidation/fake_invalidation_service.h" 14 #include "chrome/browser/invalidation/profile_invalidation_provider_factory.h" 15 #include "chrome/browser/signin/fake_profile_oauth2_token_service.h" 16 #include "chrome/browser/signin/fake_profile_oauth2_token_service_builder.h" 17 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h" 18 #include "chrome/browser/signin/signin_manager_factory.h" 19 #include "chrome/browser/sync/glue/sync_backend_host_mock.h" 20 #include "chrome/browser/sync/managed_user_signin_manager_wrapper.h" 21 #include "chrome/browser/sync/profile_sync_components_factory_mock.h" 22 #include "chrome/common/chrome_switches.h" 23 #include "chrome/common/pref_names.h" 24 #include "chrome/test/base/testing_browser_process.h" 25 #include "chrome/test/base/testing_pref_service_syncable.h" 26 #include "chrome/test/base/testing_profile.h" 27 #include "chrome/test/base/testing_profile_manager.h" 28 #include "components/invalidation/invalidation_service.h" 29 #include "components/invalidation/profile_invalidation_provider.h" 30 #include "components/signin/core/browser/signin_manager.h" 31 #include "components/sync_driver/data_type_manager_impl.h" 32 #include "components/sync_driver/pref_names.h" 33 #include "components/sync_driver/sync_prefs.h" 34 #include "content/public/test/test_browser_thread_bundle.h" 35 #include "google_apis/gaia/gaia_constants.h" 36 #include "testing/gmock/include/gmock/gmock.h" 37 #include "testing/gtest/include/gtest/gtest.h" 38 39 namespace content { 40 class BrowserContext; 41 } 42 43 namespace browser_sync { 44 45 namespace { 46 47 ACTION(ReturnNewDataTypeManager) { 48 return new browser_sync::DataTypeManagerImpl(base::Closure(), 49 arg0, 50 arg1, 51 arg2, 52 arg3, 53 arg4, 54 arg5); 55 } 56 57 using testing::Return; 58 using testing::StrictMock; 59 using testing::_; 60 61 class TestProfileSyncServiceObserver : public ProfileSyncServiceObserver { 62 public: 63 explicit TestProfileSyncServiceObserver(ProfileSyncService* service) 64 : service_(service), first_setup_in_progress_(false) {} 65 virtual void OnStateChanged() OVERRIDE { 66 first_setup_in_progress_ = service_->FirstSetupInProgress(); 67 } 68 bool first_setup_in_progress() const { return first_setup_in_progress_; } 69 private: 70 ProfileSyncService* service_; 71 bool first_setup_in_progress_; 72 }; 73 74 // A variant of the SyncBackendHostMock that won't automatically 75 // call back when asked to initialized. Allows us to test things 76 // that could happen while backend init is in progress. 77 class SyncBackendHostNoReturn : public SyncBackendHostMock { 78 virtual void Initialize( 79 SyncFrontend* frontend, 80 scoped_ptr<base::Thread> sync_thread, 81 const syncer::WeakHandle<syncer::JsEventHandler>& event_handler, 82 const GURL& service_url, 83 const syncer::SyncCredentials& credentials, 84 bool delete_sync_data_folder, 85 scoped_ptr<syncer::SyncManagerFactory> sync_manager_factory, 86 scoped_ptr<syncer::UnrecoverableErrorHandler> unrecoverable_error_handler, 87 syncer::ReportUnrecoverableErrorFunction 88 report_unrecoverable_error_function, 89 syncer::NetworkResources* network_resources) OVERRIDE {} 90 }; 91 92 class SyncBackendHostMockCollectDeleteDirParam : public SyncBackendHostMock { 93 public: 94 explicit SyncBackendHostMockCollectDeleteDirParam( 95 std::vector<bool>* delete_dir_param) 96 : delete_dir_param_(delete_dir_param) {} 97 98 virtual void Initialize( 99 SyncFrontend* frontend, 100 scoped_ptr<base::Thread> sync_thread, 101 const syncer::WeakHandle<syncer::JsEventHandler>& event_handler, 102 const GURL& service_url, 103 const syncer::SyncCredentials& credentials, 104 bool delete_sync_data_folder, 105 scoped_ptr<syncer::SyncManagerFactory> sync_manager_factory, 106 scoped_ptr<syncer::UnrecoverableErrorHandler> unrecoverable_error_handler, 107 syncer::ReportUnrecoverableErrorFunction 108 report_unrecoverable_error_function, 109 syncer::NetworkResources* network_resources) OVERRIDE { 110 delete_dir_param_->push_back(delete_sync_data_folder); 111 SyncBackendHostMock::Initialize(frontend, sync_thread.Pass(), 112 event_handler, service_url, credentials, 113 delete_sync_data_folder, 114 sync_manager_factory.Pass(), 115 unrecoverable_error_handler.Pass(), 116 report_unrecoverable_error_function, 117 network_resources); 118 } 119 120 private: 121 std::vector<bool>* delete_dir_param_; 122 }; 123 124 ACTION(ReturnNewSyncBackendHostMock) { 125 return new browser_sync::SyncBackendHostMock(); 126 } 127 128 ACTION(ReturnNewSyncBackendHostNoReturn) { 129 return new browser_sync::SyncBackendHostNoReturn(); 130 } 131 132 ACTION_P(ReturnNewMockHostCollectDeleteDirParam, delete_dir_param) { 133 return new browser_sync::SyncBackendHostMockCollectDeleteDirParam( 134 delete_dir_param); 135 } 136 137 KeyedService* BuildFakeProfileInvalidationProvider( 138 content::BrowserContext* context) { 139 return new invalidation::ProfileInvalidationProvider( 140 scoped_ptr<invalidation::InvalidationService>( 141 new invalidation::FakeInvalidationService)); 142 } 143 144 // A test harness that uses a real ProfileSyncService and in most cases a 145 // MockSyncBackendHost. 146 // 147 // This is useful if we want to test the ProfileSyncService and don't care about 148 // testing the SyncBackendHost. 149 class ProfileSyncServiceTest : public ::testing::Test { 150 protected: 151 ProfileSyncServiceTest() 152 : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP), 153 profile_manager_(TestingBrowserProcess::GetGlobal()) {} 154 virtual ~ProfileSyncServiceTest() {} 155 156 virtual void SetUp() OVERRIDE { 157 CommandLine::ForCurrentProcess()->AppendSwitchASCII( 158 switches::kSyncDeferredStartupTimeoutSeconds, "0"); 159 160 CHECK(profile_manager_.SetUp()); 161 162 TestingProfile::TestingFactories testing_facotries; 163 testing_facotries.push_back( 164 std::make_pair(ProfileOAuth2TokenServiceFactory::GetInstance(), 165 BuildAutoIssuingFakeProfileOAuth2TokenService)); 166 testing_facotries.push_back( 167 std::make_pair( 168 invalidation::ProfileInvalidationProviderFactory::GetInstance(), 169 BuildFakeProfileInvalidationProvider)); 170 171 profile_ = profile_manager_.CreateTestingProfile( 172 "sync-service-test", scoped_ptr<PrefServiceSyncable>(), 173 base::UTF8ToUTF16("sync-service-test"), 0, std::string(), 174 testing_facotries); 175 } 176 177 virtual void TearDown() OVERRIDE { 178 // Kill the service before the profile. 179 if (service_) 180 service_->Shutdown(); 181 182 service_.reset(); 183 } 184 185 void IssueTestTokens() { 186 ProfileOAuth2TokenServiceFactory::GetForProfile(profile_) 187 ->UpdateCredentials("test", "oauth2_login_token"); 188 } 189 190 void CreateService(ProfileSyncServiceStartBehavior behavior) { 191 SigninManagerBase* signin = 192 SigninManagerFactory::GetForProfile(profile_); 193 signin->SetAuthenticatedUsername("test"); 194 ProfileOAuth2TokenService* oauth2_token_service = 195 ProfileOAuth2TokenServiceFactory::GetForProfile(profile_); 196 components_factory_ = new StrictMock<ProfileSyncComponentsFactoryMock>(); 197 service_.reset(new ProfileSyncService( 198 components_factory_, 199 profile_, 200 make_scoped_ptr(new ManagedUserSigninManagerWrapper(profile_, signin)), 201 oauth2_token_service, 202 behavior)); 203 service_->SetClearingBrowseringDataForTesting( 204 base::Bind(&ProfileSyncServiceTest::ClearBrowsingDataCallback, 205 base::Unretained(this))); 206 } 207 208 #if defined(OS_WIN) || defined(OS_MACOSX) || (defined(OS_LINUX) && !defined(OS_CHROMEOS)) 209 void CreateServiceWithoutSignIn() { 210 CreateService(browser_sync::MANUAL_START); 211 SigninManagerFactory::GetForProfile(profile())->SignOut( 212 signin_metrics::SIGNOUT_TEST); 213 service()->SetBackupStartDelayForTest( 214 base::TimeDelta::FromMilliseconds(100)); 215 } 216 #endif 217 218 void ShutdownAndDeleteService() { 219 if (service_) 220 service_->Shutdown(); 221 service_.reset(); 222 } 223 224 void Initialize() { 225 service_->Initialize(); 226 } 227 228 void ExpectDataTypeManagerCreation(int times) { 229 EXPECT_CALL(*components_factory_, CreateDataTypeManager(_, _, _, _, _, _)) 230 .Times(times) 231 .WillRepeatedly(ReturnNewDataTypeManager()); 232 } 233 234 void ExpectSyncBackendHostCreation(int times) { 235 EXPECT_CALL(*components_factory_, CreateSyncBackendHost(_, _, _, _, _)) 236 .Times(times) 237 .WillRepeatedly(ReturnNewSyncBackendHostMock()); 238 } 239 240 void ExpectSyncBackendHostCreationCollectDeleteDir( 241 int times, std::vector<bool> *delete_dir_param) { 242 EXPECT_CALL(*components_factory_, CreateSyncBackendHost(_, _, _, _, _)) 243 .Times(times) 244 .WillRepeatedly(ReturnNewMockHostCollectDeleteDirParam( 245 delete_dir_param)); 246 } 247 248 void PrepareDelayedInitSyncBackendHost() { 249 EXPECT_CALL(*components_factory_, CreateSyncBackendHost(_, _, _, _, _)). 250 WillOnce(ReturnNewSyncBackendHostNoReturn()); 251 } 252 253 TestingProfile* profile() { 254 return profile_; 255 } 256 257 ProfileSyncService* service() { 258 return service_.get(); 259 } 260 261 ProfileSyncComponentsFactoryMock* components_factory() { 262 return components_factory_; 263 } 264 265 void ClearBrowsingDataCallback(Profile* profile, base::Time start, 266 base::Time end) { 267 EXPECT_EQ(profile_, profile); 268 clear_browsing_data_start_ = start; 269 } 270 271 protected: 272 // The requested start time when ClearBrowsingDataCallback is called. 273 base::Time clear_browsing_data_start_; 274 275 private: 276 content::TestBrowserThreadBundle thread_bundle_; 277 TestingProfileManager profile_manager_; 278 TestingProfile* profile_; 279 scoped_ptr<ProfileSyncService> service_; 280 281 // Pointer to the components factory. Not owned. May be null. 282 ProfileSyncComponentsFactoryMock* components_factory_; 283 }; 284 285 // Verify that the server URLs are sane. 286 TEST_F(ProfileSyncServiceTest, InitialState) { 287 CreateService(browser_sync::AUTO_START); 288 Initialize(); 289 const std::string& url = service()->sync_service_url().spec(); 290 EXPECT_TRUE(url == ProfileSyncService::kSyncServerUrl || 291 url == ProfileSyncService::kDevServerUrl); 292 } 293 294 // Verify a successful initialization. 295 TEST_F(ProfileSyncServiceTest, SuccessfulInitialization) { 296 profile()->GetTestingPrefService()->SetManagedPref( 297 sync_driver::prefs::kSyncManaged, base::Value::CreateBooleanValue(false)); 298 IssueTestTokens(); 299 CreateService(browser_sync::AUTO_START); 300 ExpectDataTypeManagerCreation(1); 301 ExpectSyncBackendHostCreation(1); 302 Initialize(); 303 EXPECT_FALSE(service()->IsManaged()); 304 EXPECT_TRUE(service()->sync_initialized()); 305 EXPECT_EQ(ProfileSyncService::SYNC, service()->backend_mode()); 306 } 307 308 309 // Verify that the SetSetupInProgress function call updates state 310 // and notifies observers. 311 TEST_F(ProfileSyncServiceTest, SetupInProgress) { 312 CreateService(browser_sync::AUTO_START); 313 Initialize(); 314 315 TestProfileSyncServiceObserver observer(service()); 316 service()->AddObserver(&observer); 317 318 service()->SetSetupInProgress(true); 319 EXPECT_TRUE(observer.first_setup_in_progress()); 320 service()->SetSetupInProgress(false); 321 EXPECT_FALSE(observer.first_setup_in_progress()); 322 323 service()->RemoveObserver(&observer); 324 } 325 326 // Verify that disable by enterprise policy works. 327 TEST_F(ProfileSyncServiceTest, DisabledByPolicyBeforeInit) { 328 profile()->GetTestingPrefService()->SetManagedPref( 329 sync_driver::prefs::kSyncManaged, base::Value::CreateBooleanValue(true)); 330 IssueTestTokens(); 331 CreateService(browser_sync::AUTO_START); 332 Initialize(); 333 EXPECT_TRUE(service()->IsManaged()); 334 EXPECT_FALSE(service()->sync_initialized()); 335 } 336 337 // Verify that disable by enterprise policy works even after the backend has 338 // been initialized. 339 TEST_F(ProfileSyncServiceTest, DisabledByPolicyAfterInit) { 340 IssueTestTokens(); 341 CreateService(browser_sync::AUTO_START); 342 ExpectDataTypeManagerCreation(1); 343 ExpectSyncBackendHostCreation(1); 344 Initialize(); 345 346 EXPECT_FALSE(service()->IsManaged()); 347 EXPECT_TRUE(service()->sync_initialized()); 348 349 profile()->GetTestingPrefService()->SetManagedPref( 350 sync_driver::prefs::kSyncManaged, base::Value::CreateBooleanValue(true)); 351 352 EXPECT_TRUE(service()->IsManaged()); 353 EXPECT_FALSE(service()->sync_initialized()); 354 } 355 356 // Exercies the ProfileSyncService's code paths related to getting shut down 357 // before the backend initialize call returns. 358 TEST_F(ProfileSyncServiceTest, AbortedByShutdown) { 359 CreateService(browser_sync::AUTO_START); 360 PrepareDelayedInitSyncBackendHost(); 361 362 IssueTestTokens(); 363 Initialize(); 364 EXPECT_FALSE(service()->sync_initialized()); 365 366 ShutdownAndDeleteService(); 367 } 368 369 // Test StopAndSuppress() before we've initialized the backend. 370 TEST_F(ProfileSyncServiceTest, EarlyStopAndSuppress) { 371 CreateService(browser_sync::AUTO_START); 372 IssueTestTokens(); 373 374 service()->StopAndSuppress(); 375 EXPECT_TRUE(profile()->GetPrefs()->GetBoolean( 376 sync_driver::prefs::kSyncSuppressStart)); 377 378 // Because of supression, this should fail. 379 Initialize(); 380 EXPECT_FALSE(service()->sync_initialized()); 381 382 // Remove suppression. This should be enough to allow init to happen. 383 ExpectDataTypeManagerCreation(1); 384 ExpectSyncBackendHostCreation(1); 385 service()->UnsuppressAndStart(); 386 EXPECT_TRUE(service()->sync_initialized()); 387 EXPECT_FALSE(profile()->GetPrefs()->GetBoolean( 388 sync_driver::prefs::kSyncSuppressStart)); 389 } 390 391 // Test StopAndSuppress() after we've initialized the backend. 392 TEST_F(ProfileSyncServiceTest, DisableAndEnableSyncTemporarily) { 393 CreateService(browser_sync::AUTO_START); 394 IssueTestTokens(); 395 ExpectDataTypeManagerCreation(1); 396 ExpectSyncBackendHostCreation(1); 397 Initialize(); 398 399 EXPECT_TRUE(service()->sync_initialized()); 400 EXPECT_FALSE(profile()->GetPrefs()->GetBoolean( 401 sync_driver::prefs::kSyncSuppressStart)); 402 403 testing::Mock::VerifyAndClearExpectations(components_factory()); 404 405 service()->StopAndSuppress(); 406 EXPECT_FALSE(service()->sync_initialized()); 407 EXPECT_TRUE(profile()->GetPrefs()->GetBoolean( 408 sync_driver::prefs::kSyncSuppressStart)); 409 410 ExpectDataTypeManagerCreation(1); 411 ExpectSyncBackendHostCreation(1); 412 413 service()->UnsuppressAndStart(); 414 EXPECT_TRUE(service()->sync_initialized()); 415 EXPECT_FALSE(profile()->GetPrefs()->GetBoolean( 416 sync_driver::prefs::kSyncSuppressStart)); 417 } 418 419 // Certain ProfileSyncService tests don't apply to Chrome OS, for example 420 // things that deal with concepts like "signing out" and policy. 421 #if defined(OS_WIN) || defined(OS_MACOSX) || (defined(OS_LINUX) && !defined(OS_CHROMEOS)) 422 TEST_F(ProfileSyncServiceTest, EnableSyncAndSignOutDesktop) { 423 CreateService(browser_sync::AUTO_START); 424 ExpectDataTypeManagerCreation(2); 425 ExpectSyncBackendHostCreation(2); 426 IssueTestTokens(); 427 Initialize(); 428 429 EXPECT_TRUE(service()->sync_initialized()); 430 EXPECT_FALSE(profile()->GetPrefs()->GetBoolean( 431 sync_driver::prefs::kSyncSuppressStart)); 432 EXPECT_EQ(ProfileSyncService::SYNC, service()->backend_mode()); 433 434 SigninManagerFactory::GetForProfile(profile())->SignOut( 435 signin_metrics::SIGNOUT_TEST); 436 EXPECT_TRUE(service()->sync_initialized()); 437 EXPECT_EQ(ProfileSyncService::BACKUP, service()->backend_mode()); 438 } 439 #elif !defined (OS_CHROMEOS) 440 TEST_F(ProfileSyncServiceTest, EnableSyncAndSignOut) { 441 CreateService(browser_sync::AUTO_START); 442 ExpectDataTypeManagerCreation(1); 443 ExpectSyncBackendHostCreation(1); 444 IssueTestTokens(); 445 Initialize(); 446 447 EXPECT_TRUE(service()->sync_initialized()); 448 EXPECT_FALSE(profile()->GetPrefs()->GetBoolean( 449 sync_driver::prefs::kSyncSuppressStart)); 450 451 SigninManagerFactory::GetForProfile(profile())->SignOut( 452 signin_metrics::SIGNOUT_TEST); 453 EXPECT_FALSE(service()->sync_initialized()); 454 } 455 #endif // !defined(OS_CHROMEOS) 456 457 TEST_F(ProfileSyncServiceTest, GetSyncTokenStatus) { 458 CreateService(browser_sync::AUTO_START); 459 IssueTestTokens(); 460 ExpectDataTypeManagerCreation(1); 461 ExpectSyncBackendHostCreation(1); 462 Initialize(); 463 464 // Initial status. 465 ProfileSyncService::SyncTokenStatus token_status = 466 service()->GetSyncTokenStatus(); 467 EXPECT_EQ(syncer::CONNECTION_NOT_ATTEMPTED, token_status.connection_status); 468 EXPECT_TRUE(token_status.connection_status_update_time.is_null()); 469 EXPECT_TRUE(token_status.token_request_time.is_null()); 470 EXPECT_TRUE(token_status.token_receive_time.is_null()); 471 472 // Simulate an auth error. 473 service()->OnConnectionStatusChange(syncer::CONNECTION_AUTH_ERROR); 474 475 // The token request will take the form of a posted task. Run it. 476 base::RunLoop loop; 477 loop.RunUntilIdle(); 478 479 token_status = service()->GetSyncTokenStatus(); 480 EXPECT_EQ(syncer::CONNECTION_AUTH_ERROR, token_status.connection_status); 481 EXPECT_FALSE(token_status.connection_status_update_time.is_null()); 482 EXPECT_FALSE(token_status.token_request_time.is_null()); 483 EXPECT_FALSE(token_status.token_receive_time.is_null()); 484 EXPECT_EQ(GoogleServiceAuthError::AuthErrorNone(), 485 token_status.last_get_token_error); 486 EXPECT_TRUE(token_status.next_token_request_time.is_null()); 487 488 // Simulate successful connection. 489 service()->OnConnectionStatusChange(syncer::CONNECTION_OK); 490 token_status = service()->GetSyncTokenStatus(); 491 EXPECT_EQ(syncer::CONNECTION_OK, token_status.connection_status); 492 } 493 494 #if defined(ENABLE_PRE_SYNC_BACKUP) 495 TEST_F(ProfileSyncServiceTest, StartBackup) { 496 CreateServiceWithoutSignIn(); 497 ExpectDataTypeManagerCreation(1); 498 std::vector<bool> delete_dir_param; 499 ExpectSyncBackendHostCreationCollectDeleteDir(1, &delete_dir_param); 500 Initialize(); 501 EXPECT_EQ(ProfileSyncService::IDLE, service()->backend_mode()); 502 base::RunLoop run_loop; 503 base::MessageLoop::current()->PostDelayedTask( 504 FROM_HERE, run_loop.QuitClosure(), 505 base::TimeDelta::FromMilliseconds(100)); 506 run_loop.Run(); 507 EXPECT_EQ(ProfileSyncService::BACKUP, service()->backend_mode()); 508 509 EXPECT_EQ(1u, delete_dir_param.size()); 510 EXPECT_FALSE(delete_dir_param[0]); 511 } 512 513 TEST_F(ProfileSyncServiceTest, BackupAfterSyncDisabled) { 514 CreateService(browser_sync::MANUAL_START); 515 service()->SetSyncSetupCompleted(); 516 ExpectDataTypeManagerCreation(2); 517 std::vector<bool> delete_dir_param; 518 ExpectSyncBackendHostCreationCollectDeleteDir(2, &delete_dir_param); 519 IssueTestTokens(); 520 Initialize(); 521 EXPECT_TRUE(service()->sync_initialized()); 522 EXPECT_EQ(ProfileSyncService::SYNC, service()->backend_mode()); 523 524 // First sync time should be recorded. 525 sync_driver::SyncPrefs sync_prefs(service()->profile()->GetPrefs()); 526 EXPECT_FALSE(sync_prefs.GetFirstSyncTime().is_null()); 527 528 syncer::SyncProtocolError client_cmd; 529 client_cmd.action = syncer::DISABLE_SYNC_ON_CLIENT; 530 service()->OnActionableError(client_cmd); 531 EXPECT_EQ(ProfileSyncService::BACKUP, service()->backend_mode()); 532 533 // Browsing data is not cleared because rollback is skipped. 534 EXPECT_TRUE(clear_browsing_data_start_.is_null()); 535 536 // First sync time is erased once backup starts. 537 EXPECT_TRUE(sync_prefs.GetFirstSyncTime().is_null()); 538 539 EXPECT_EQ(2u, delete_dir_param.size()); 540 EXPECT_FALSE(delete_dir_param[0]); 541 EXPECT_TRUE(delete_dir_param[1]); 542 } 543 544 TEST_F(ProfileSyncServiceTest, RollbackThenBackup) { 545 CommandLine::ForCurrentProcess()->AppendSwitch( 546 switches::kSyncEnableRollback); 547 548 CreateService(browser_sync::MANUAL_START); 549 service()->SetSyncSetupCompleted(); 550 ExpectDataTypeManagerCreation(3); 551 std::vector<bool> delete_dir_param; 552 ExpectSyncBackendHostCreationCollectDeleteDir(3, &delete_dir_param); 553 IssueTestTokens(); 554 Initialize(); 555 EXPECT_TRUE(service()->sync_initialized()); 556 EXPECT_EQ(ProfileSyncService::SYNC, service()->backend_mode()); 557 558 // First sync time should be recorded. 559 sync_driver::SyncPrefs sync_prefs(service()->profile()->GetPrefs()); 560 base::Time first_sync_time = sync_prefs.GetFirstSyncTime(); 561 EXPECT_FALSE(first_sync_time.is_null()); 562 563 syncer::SyncProtocolError client_cmd; 564 client_cmd.action = syncer::DISABLE_SYNC_AND_ROLLBACK; 565 service()->OnActionableError(client_cmd); 566 EXPECT_TRUE(service()->sync_initialized()); 567 EXPECT_EQ(ProfileSyncService::ROLLBACK, service()->backend_mode()); 568 569 // Browser data should be cleared during rollback. 570 EXPECT_EQ(first_sync_time, clear_browsing_data_start_); 571 572 client_cmd.action = syncer::ROLLBACK_DONE; 573 service()->OnActionableError(client_cmd); 574 EXPECT_TRUE(service()->sync_initialized()); 575 EXPECT_EQ(ProfileSyncService::BACKUP, service()->backend_mode()); 576 577 // First sync time is erased once backup starts. 578 EXPECT_TRUE(sync_prefs.GetFirstSyncTime().is_null()); 579 580 EXPECT_EQ(3u, delete_dir_param.size()); 581 EXPECT_FALSE(delete_dir_param[0]); 582 EXPECT_FALSE(delete_dir_param[1]); 583 EXPECT_TRUE(delete_dir_param[2]); 584 } 585 586 TEST_F(ProfileSyncServiceTest, StartNewBackupDbOnSettingsReset) { 587 CreateServiceWithoutSignIn(); 588 ExpectDataTypeManagerCreation(1); 589 std::vector<bool> delete_dir_param; 590 ExpectSyncBackendHostCreationCollectDeleteDir(1, &delete_dir_param); 591 Initialize(); 592 EXPECT_EQ(ProfileSyncService::IDLE, service()->backend_mode()); 593 594 // Set reset time to pretend settings reset happened. 595 profile()->GetPrefs()->SetString( 596 prefs::kPreferenceResetTime, 597 base::Int64ToString(base::Time::Now().ToInternalValue())); 598 599 base::RunLoop run_loop; 600 base::MessageLoop::current()->PostDelayedTask( 601 FROM_HERE, run_loop.QuitClosure(), 602 base::TimeDelta::FromMilliseconds(100)); 603 run_loop.Run(); 604 605 EXPECT_EQ(ProfileSyncService::BACKUP, service()->backend_mode()); 606 607 EXPECT_EQ(1u, delete_dir_param.size()); 608 EXPECT_TRUE(delete_dir_param[0]); 609 } 610 611 #endif 612 613 TEST_F(ProfileSyncServiceTest, GetSyncServiceURL) { 614 // See that we can override the URL with a flag. 615 CommandLine command_line( 616 base::FilePath(base::FilePath(FILE_PATH_LITERAL("chrome.exe")))); 617 command_line.AppendSwitchASCII(switches::kSyncServiceURL, "https://foo/bar"); 618 EXPECT_EQ("https://foo/bar", 619 ProfileSyncService::GetSyncServiceURL(command_line).spec()); 620 } 621 622 } // namespace 623 } // namespace browser_sync 624