1 // Copyright 2013 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 "chrome/browser/sync/glue/sync_backend_host_impl.h" 6 7 #include <cstddef> 8 9 #include "base/files/file_util.h" 10 #include "base/location.h" 11 #include "base/memory/scoped_ptr.h" 12 #include "base/message_loop/message_loop.h" 13 #include "base/synchronization/waitable_event.h" 14 #include "base/test/test_timeouts.h" 15 #include "chrome/browser/chrome_notification_types.h" 16 #include "chrome/browser/invalidation/profile_invalidation_provider_factory.h" 17 #include "chrome/browser/prefs/pref_service_syncable.h" 18 #include "chrome/test/base/testing_browser_process.h" 19 #include "chrome/test/base/testing_profile.h" 20 #include "chrome/test/base/testing_profile_manager.h" 21 #include "components/invalidation/invalidator_state.h" 22 #include "components/invalidation/invalidator_storage.h" 23 #include "components/invalidation/profile_invalidation_provider.h" 24 #include "components/sync_driver/device_info.h" 25 #include "components/sync_driver/sync_frontend.h" 26 #include "components/sync_driver/sync_prefs.h" 27 #include "content/public/browser/notification_service.h" 28 #include "content/public/test/test_browser_thread_bundle.h" 29 #include "content/public/test/test_utils.h" 30 #include "google/cacheinvalidation/include/types.h" 31 #include "google_apis/gaia/gaia_constants.h" 32 #include "net/url_request/test_url_fetcher_factory.h" 33 #include "sync/internal_api/public/base/model_type.h" 34 #include "sync/internal_api/public/engine/model_safe_worker.h" 35 #include "sync/internal_api/public/http_bridge_network_resources.h" 36 #include "sync/internal_api/public/network_resources.h" 37 #include "sync/internal_api/public/sessions/commit_counters.h" 38 #include "sync/internal_api/public/sessions/status_counters.h" 39 #include "sync/internal_api/public/sessions/update_counters.h" 40 #include "sync/internal_api/public/sync_manager_factory.h" 41 #include "sync/internal_api/public/test/fake_sync_manager.h" 42 #include "sync/internal_api/public/util/experiments.h" 43 #include "sync/protocol/encryption.pb.h" 44 #include "sync/protocol/sync_protocol_error.h" 45 #include "sync/util/test_unrecoverable_error_handler.h" 46 #include "testing/gmock/include/gmock/gmock.h" 47 #include "testing/gtest/include/gtest/gtest.h" 48 #include "url/gurl.h" 49 50 using content::BrowserThread; 51 using syncer::FakeSyncManager; 52 using syncer::SyncManager; 53 using ::testing::InvokeWithoutArgs; 54 using ::testing::StrictMock; 55 using ::testing::_; 56 57 namespace browser_sync { 58 59 namespace { 60 61 const char kTestProfileName[] = "test-profile"; 62 63 static const base::FilePath::CharType kTestSyncDir[] = 64 FILE_PATH_LITERAL("sync-test"); 65 66 ACTION_P(Signal, event) { 67 event->Signal(); 68 } 69 70 void QuitMessageLoop() { 71 base::MessageLoop::current()->Quit(); 72 } 73 74 class MockSyncFrontend : public sync_driver::SyncFrontend { 75 public: 76 virtual ~MockSyncFrontend() {} 77 78 MOCK_METHOD4( 79 OnBackendInitialized, 80 void(const syncer::WeakHandle<syncer::JsBackend>&, 81 const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&, 82 const std::string&, 83 bool)); 84 MOCK_METHOD0(OnSyncCycleCompleted, void()); 85 MOCK_METHOD1(OnConnectionStatusChange, 86 void(syncer::ConnectionStatus status)); 87 MOCK_METHOD0(OnClearServerDataSucceeded, void()); 88 MOCK_METHOD0(OnClearServerDataFailed, void()); 89 MOCK_METHOD2(OnPassphraseRequired, 90 void(syncer::PassphraseRequiredReason, 91 const sync_pb::EncryptedData&)); 92 MOCK_METHOD0(OnPassphraseAccepted, void()); 93 MOCK_METHOD2(OnEncryptedTypesChanged, 94 void(syncer::ModelTypeSet, bool)); 95 MOCK_METHOD0(OnEncryptionComplete, void()); 96 MOCK_METHOD1(OnMigrationNeededForTypes, void(syncer::ModelTypeSet)); 97 MOCK_METHOD1(OnProtocolEvent, void(const syncer::ProtocolEvent&)); 98 MOCK_METHOD2(OnDirectoryTypeCommitCounterUpdated, 99 void(syncer::ModelType, const syncer::CommitCounters&)); 100 MOCK_METHOD2(OnDirectoryTypeUpdateCounterUpdated, 101 void(syncer::ModelType, const syncer::UpdateCounters&)); 102 MOCK_METHOD2(OnDirectoryTypeStatusCounterUpdated, 103 void(syncer::ModelType, const syncer::StatusCounters&)); 104 MOCK_METHOD1(OnExperimentsChanged, 105 void(const syncer::Experiments&)); 106 MOCK_METHOD1(OnActionableError, 107 void(const syncer::SyncProtocolError& sync_error)); 108 MOCK_METHOD0(OnSyncConfigureRetry, void()); 109 }; 110 111 class FakeSyncManagerFactory : public syncer::SyncManagerFactory { 112 public: 113 explicit FakeSyncManagerFactory(FakeSyncManager** fake_manager) 114 : SyncManagerFactory(NORMAL), 115 fake_manager_(fake_manager) { 116 *fake_manager_ = NULL; 117 } 118 virtual ~FakeSyncManagerFactory() {} 119 120 // SyncManagerFactory implementation. Called on the sync thread. 121 virtual scoped_ptr<SyncManager> CreateSyncManager( 122 std::string name) OVERRIDE { 123 *fake_manager_ = new FakeSyncManager(initial_sync_ended_types_, 124 progress_marker_types_, 125 configure_fail_types_); 126 return scoped_ptr<SyncManager>(*fake_manager_); 127 } 128 129 void set_initial_sync_ended_types(syncer::ModelTypeSet types) { 130 initial_sync_ended_types_ = types; 131 } 132 133 void set_progress_marker_types(syncer::ModelTypeSet types) { 134 progress_marker_types_ = types; 135 } 136 137 void set_configure_fail_types(syncer::ModelTypeSet types) { 138 configure_fail_types_ = types; 139 } 140 141 private: 142 syncer::ModelTypeSet initial_sync_ended_types_; 143 syncer::ModelTypeSet progress_marker_types_; 144 syncer::ModelTypeSet configure_fail_types_; 145 FakeSyncManager** fake_manager_; 146 }; 147 148 class SyncBackendHostTest : public testing::Test { 149 protected: 150 SyncBackendHostTest() 151 : thread_bundle_(content::TestBrowserThreadBundle::REAL_IO_THREAD), 152 profile_manager_(TestingBrowserProcess::GetGlobal()), 153 fake_manager_(NULL) {} 154 155 virtual ~SyncBackendHostTest() {} 156 157 virtual void SetUp() OVERRIDE { 158 ASSERT_TRUE(profile_manager_.SetUp()); 159 profile_ = profile_manager_.CreateTestingProfile(kTestProfileName); 160 sync_prefs_.reset(new sync_driver::SyncPrefs(profile_->GetPrefs())); 161 backend_.reset(new SyncBackendHostImpl( 162 profile_->GetDebugName(), 163 profile_, 164 invalidation::ProfileInvalidationProviderFactory::GetForProfile( 165 profile_)->GetInvalidationService(), 166 sync_prefs_->AsWeakPtr(), 167 base::FilePath(kTestSyncDir))); 168 credentials_.email = "user (at) example.com"; 169 credentials_.sync_token = "sync_token"; 170 credentials_.scope_set.insert(GaiaConstants::kChromeSyncOAuth2Scope); 171 172 fake_manager_factory_.reset(new FakeSyncManagerFactory(&fake_manager_)); 173 174 // These types are always implicitly enabled. 175 enabled_types_.PutAll(syncer::ControlTypes()); 176 177 // NOTE: We can't include Passwords or Typed URLs due to the Sync Backend 178 // Registrar removing them if it can't find their model workers. 179 enabled_types_.Put(syncer::BOOKMARKS); 180 enabled_types_.Put(syncer::NIGORI); 181 enabled_types_.Put(syncer::DEVICE_INFO); 182 enabled_types_.Put(syncer::PREFERENCES); 183 enabled_types_.Put(syncer::SESSIONS); 184 enabled_types_.Put(syncer::SEARCH_ENGINES); 185 enabled_types_.Put(syncer::AUTOFILL); 186 enabled_types_.Put(syncer::EXPERIMENTS); 187 188 network_resources_.reset(new syncer::HttpBridgeNetworkResources()); 189 } 190 191 virtual void TearDown() OVERRIDE { 192 if (backend_) { 193 backend_->StopSyncingForShutdown(); 194 backend_->Shutdown(syncer::STOP_SYNC); 195 } 196 backend_.reset(); 197 sync_prefs_.reset(); 198 profile_ = NULL; 199 profile_manager_.DeleteTestingProfile(kTestProfileName); 200 // Pump messages posted by the sync thread (which may end up 201 // posting on the IO thread). 202 base::RunLoop().RunUntilIdle(); 203 content::RunAllPendingInMessageLoop(BrowserThread::IO); 204 // Pump any messages posted by the IO thread. 205 base::RunLoop().RunUntilIdle(); 206 } 207 208 // Synchronously initializes the backend. 209 void InitializeBackend(bool expect_success) { 210 EXPECT_CALL(mock_frontend_, OnBackendInitialized(_, _, _, expect_success)). 211 WillOnce(InvokeWithoutArgs(QuitMessageLoop)); 212 backend_->Initialize( 213 &mock_frontend_, 214 scoped_ptr<base::Thread>(), 215 syncer::WeakHandle<syncer::JsEventHandler>(), 216 GURL(std::string()), 217 credentials_, 218 true, 219 fake_manager_factory_.PassAs<syncer::SyncManagerFactory>(), 220 scoped_ptr<syncer::UnrecoverableErrorHandler>( 221 new syncer::TestUnrecoverableErrorHandler).Pass(), 222 NULL, 223 network_resources_.get()); 224 base::RunLoop run_loop; 225 BrowserThread::PostDelayedTask(BrowserThread::UI, FROM_HERE, 226 run_loop.QuitClosure(), 227 TestTimeouts::action_timeout()); 228 run_loop.Run(); 229 // |fake_manager_factory_|'s fake_manager() is set on the sync 230 // thread, but we can rely on the message loop barriers to 231 // guarantee that we see the updated value. 232 DCHECK(fake_manager_); 233 } 234 235 // Synchronously configures the backend's datatypes. 236 void ConfigureDataTypes(syncer::ModelTypeSet types_to_add, 237 syncer::ModelTypeSet types_to_remove, 238 syncer::ModelTypeSet types_to_unapply) { 239 sync_driver::BackendDataTypeConfigurer::DataTypeConfigStateMap 240 config_state_map; 241 sync_driver::BackendDataTypeConfigurer::SetDataTypesState( 242 sync_driver::BackendDataTypeConfigurer::CONFIGURE_ACTIVE, 243 types_to_add, 244 &config_state_map); 245 sync_driver::BackendDataTypeConfigurer::SetDataTypesState( 246 sync_driver::BackendDataTypeConfigurer::DISABLED, 247 types_to_remove, &config_state_map); 248 sync_driver::BackendDataTypeConfigurer::SetDataTypesState( 249 sync_driver::BackendDataTypeConfigurer::UNREADY, 250 types_to_unapply, &config_state_map); 251 252 types_to_add.PutAll(syncer::ControlTypes()); 253 backend_->ConfigureDataTypes( 254 syncer::CONFIGURE_REASON_RECONFIGURATION, 255 config_state_map, 256 base::Bind(&SyncBackendHostTest::DownloadReady, 257 base::Unretained(this)), 258 base::Bind(&SyncBackendHostTest::OnDownloadRetry, 259 base::Unretained(this))); 260 base::RunLoop run_loop; 261 BrowserThread::PostDelayedTask(BrowserThread::UI, FROM_HERE, 262 run_loop.QuitClosure(), 263 TestTimeouts::action_timeout()); 264 run_loop.Run(); 265 } 266 267 void IssueRefreshRequest(syncer::ModelTypeSet types) { 268 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 269 270 content::NotificationService::current()->Notify( 271 chrome::NOTIFICATION_SYNC_REFRESH_LOCAL, 272 content::Source<Profile>(profile_), 273 content::Details<syncer::ModelTypeSet>(&types)); 274 } 275 276 protected: 277 void DownloadReady(syncer::ModelTypeSet succeeded_types, 278 syncer::ModelTypeSet failed_types) { 279 base::MessageLoop::current()->Quit(); 280 } 281 282 void OnDownloadRetry() { 283 NOTIMPLEMENTED(); 284 } 285 286 content::TestBrowserThreadBundle thread_bundle_; 287 StrictMock<MockSyncFrontend> mock_frontend_; 288 syncer::SyncCredentials credentials_; 289 TestingProfileManager profile_manager_; 290 TestingProfile* profile_; 291 scoped_ptr<sync_driver::SyncPrefs> sync_prefs_; 292 scoped_ptr<SyncBackendHost> backend_; 293 scoped_ptr<FakeSyncManagerFactory> fake_manager_factory_; 294 FakeSyncManager* fake_manager_; 295 syncer::ModelTypeSet enabled_types_; 296 scoped_ptr<syncer::NetworkResources> network_resources_; 297 }; 298 299 // Test basic initialization with no initial types (first time initialization). 300 // Only the nigori should be configured. 301 TEST_F(SyncBackendHostTest, InitShutdown) { 302 InitializeBackend(true); 303 EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals( 304 syncer::ControlTypes())); 305 EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals( 306 syncer::ControlTypes())); 307 EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 308 syncer::ControlTypes()).Empty()); 309 } 310 311 // Test first time sync scenario. All types should be properly configured. 312 TEST_F(SyncBackendHostTest, FirstTimeSync) { 313 InitializeBackend(true); 314 EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals( 315 syncer::ControlTypes())); 316 EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals( 317 syncer::ControlTypes())); 318 EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 319 syncer::ControlTypes()).Empty()); 320 321 ConfigureDataTypes(enabled_types_, 322 Difference(syncer::ModelTypeSet::All(), 323 enabled_types_), 324 syncer::ModelTypeSet()); 325 EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().HasAll( 326 Difference(enabled_types_, syncer::ControlTypes()))); 327 EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_)); 328 EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_)); 329 EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 330 enabled_types_).Empty()); 331 } 332 333 // Test the restart after setting up sync scenario. No enabled types should be 334 // downloaded or cleaned. 335 TEST_F(SyncBackendHostTest, Restart) { 336 sync_prefs_->SetSyncSetupCompleted(); 337 syncer::ModelTypeSet all_but_nigori = enabled_types_; 338 fake_manager_factory_->set_progress_marker_types(enabled_types_); 339 fake_manager_factory_->set_initial_sync_ended_types(enabled_types_); 340 InitializeBackend(true); 341 EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty()); 342 EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(), 343 enabled_types_).Empty()); 344 EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_)); 345 EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 346 enabled_types_).Empty()); 347 348 ConfigureDataTypes(enabled_types_, 349 Difference(syncer::ModelTypeSet::All(), 350 enabled_types_), 351 syncer::ModelTypeSet()); 352 EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty()); 353 EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(), 354 enabled_types_).Empty()); 355 EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_)); 356 EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_)); 357 EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 358 enabled_types_).Empty()); 359 } 360 361 // Test a sync restart scenario where some types had never finished configuring. 362 // The partial types should be purged, then reconfigured properly. 363 TEST_F(SyncBackendHostTest, PartialTypes) { 364 sync_prefs_->SetSyncSetupCompleted(); 365 // Set sync manager behavior before passing it down. All types have progress 366 // markers, but nigori and bookmarks are missing initial sync ended. 367 syncer::ModelTypeSet partial_types(syncer::NIGORI, syncer::BOOKMARKS); 368 syncer::ModelTypeSet full_types = 369 Difference(enabled_types_, partial_types); 370 fake_manager_factory_->set_progress_marker_types(enabled_types_); 371 fake_manager_factory_->set_initial_sync_ended_types(full_types); 372 373 // Bringing up the backend should purge all partial types, then proceed to 374 // download the Nigori. 375 InitializeBackend(true); 376 EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals( 377 syncer::ModelTypeSet(syncer::NIGORI))); 378 EXPECT_TRUE(fake_manager_->GetAndResetCleanedTypes().HasAll(partial_types)); 379 EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals( 380 Union(full_types, syncer::ModelTypeSet(syncer::NIGORI)))); 381 EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 382 enabled_types_).Equals( 383 Difference(partial_types, syncer::ModelTypeSet(syncer::NIGORI)))); 384 385 // Now do the actual configuration, which should download and apply bookmarks. 386 ConfigureDataTypes(enabled_types_, 387 Difference(syncer::ModelTypeSet::All(), 388 enabled_types_), 389 syncer::ModelTypeSet()); 390 EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(), 391 enabled_types_).Empty()); 392 EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals( 393 partial_types)); 394 EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_)); 395 EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_)); 396 EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 397 enabled_types_).Empty()); 398 } 399 400 // Test the behavior when we lose the sync db. Although we already have types 401 // enabled, we should re-download all of them because we lost their data. 402 TEST_F(SyncBackendHostTest, LostDB) { 403 sync_prefs_->SetSyncSetupCompleted(); 404 // Initialization should fetch the Nigori node. Everything else should be 405 // left untouched. 406 InitializeBackend(true); 407 EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals( 408 syncer::ModelTypeSet(syncer::ControlTypes()))); 409 EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals( 410 syncer::ModelTypeSet(syncer::ControlTypes()))); 411 EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 412 enabled_types_).Equals( 413 Difference(enabled_types_, syncer::ControlTypes()))); 414 415 // The database was empty, so any cleaning is entirely optional. We want to 416 // reset this value before running the next part of the test, though. 417 fake_manager_->GetAndResetCleanedTypes(); 418 419 // The actual configuration should redownload and apply all the enabled types. 420 ConfigureDataTypes(enabled_types_, 421 Difference(syncer::ModelTypeSet::All(), 422 enabled_types_), 423 syncer::ModelTypeSet()); 424 EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().HasAll( 425 Difference(enabled_types_, syncer::ControlTypes()))); 426 EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(), 427 enabled_types_).Empty()); 428 EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_)); 429 EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_)); 430 EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 431 enabled_types_).Empty()); 432 } 433 434 TEST_F(SyncBackendHostTest, DisableTypes) { 435 // Simulate first time sync. 436 InitializeBackend(true); 437 fake_manager_->GetAndResetCleanedTypes(); 438 ConfigureDataTypes(enabled_types_, 439 Difference(syncer::ModelTypeSet::All(), 440 enabled_types_), 441 syncer::ModelTypeSet()); 442 EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals( 443 enabled_types_)); 444 EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(), 445 enabled_types_).Empty()); 446 EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_)); 447 EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 448 enabled_types_).Empty()); 449 450 // Then disable two datatypes. 451 syncer::ModelTypeSet disabled_types(syncer::BOOKMARKS, 452 syncer::SEARCH_ENGINES); 453 syncer::ModelTypeSet old_types = enabled_types_; 454 enabled_types_.RemoveAll(disabled_types); 455 ConfigureDataTypes(enabled_types_, 456 Difference(syncer::ModelTypeSet::All(), 457 enabled_types_), 458 syncer::ModelTypeSet()); 459 460 // Only those datatypes disabled should be cleaned. Nothing should be 461 // downloaded. 462 EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty()); 463 EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(), 464 old_types).Equals(disabled_types)); 465 EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_)); 466 EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_)); 467 EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 468 enabled_types_).Empty()); 469 } 470 471 TEST_F(SyncBackendHostTest, AddTypes) { 472 // Simulate first time sync. 473 InitializeBackend(true); 474 fake_manager_->GetAndResetCleanedTypes(); 475 ConfigureDataTypes(enabled_types_, 476 Difference(syncer::ModelTypeSet::All(), 477 enabled_types_), 478 syncer::ModelTypeSet()); 479 EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals( 480 enabled_types_)); 481 EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(), 482 enabled_types_).Empty()); 483 EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_)); 484 EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 485 enabled_types_).Empty()); 486 487 // Then add two datatypes. 488 syncer::ModelTypeSet new_types(syncer::EXTENSIONS, 489 syncer::APPS); 490 enabled_types_.PutAll(new_types); 491 ConfigureDataTypes(enabled_types_, 492 Difference(syncer::ModelTypeSet::All(), 493 enabled_types_), 494 syncer::ModelTypeSet()); 495 496 // Only those datatypes added should be downloaded (plus nigori). Nothing 497 // should be cleaned aside from the disabled types. 498 EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals( 499 Union(new_types, syncer::ModelTypeSet(syncer::NIGORI)))); 500 EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(), 501 enabled_types_).Empty()); 502 EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_)); 503 EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_)); 504 EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 505 enabled_types_).Empty()); 506 } 507 508 // And and disable in the same configuration. 509 TEST_F(SyncBackendHostTest, AddDisableTypes) { 510 // Simulate first time sync. 511 InitializeBackend(true); 512 fake_manager_->GetAndResetCleanedTypes(); 513 ConfigureDataTypes(enabled_types_, 514 Difference(syncer::ModelTypeSet::All(), 515 enabled_types_), 516 syncer::ModelTypeSet()); 517 EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals( 518 enabled_types_)); 519 EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(), 520 enabled_types_).Empty()); 521 EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_)); 522 EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 523 enabled_types_).Empty()); 524 525 // Then add two datatypes. 526 syncer::ModelTypeSet old_types = enabled_types_; 527 syncer::ModelTypeSet disabled_types(syncer::BOOKMARKS, 528 syncer::SEARCH_ENGINES); 529 syncer::ModelTypeSet new_types(syncer::EXTENSIONS, 530 syncer::APPS); 531 enabled_types_.PutAll(new_types); 532 enabled_types_.RemoveAll(disabled_types); 533 ConfigureDataTypes(enabled_types_, 534 Difference(syncer::ModelTypeSet::All(), 535 enabled_types_), 536 syncer::ModelTypeSet()); 537 538 // Only those datatypes added should be downloaded (plus nigori). Nothing 539 // should be cleaned aside from the disabled types. 540 EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals( 541 Union(new_types, syncer::ModelTypeSet(syncer::NIGORI)))); 542 EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(), 543 old_types).Equals(disabled_types)); 544 EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_)); 545 EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_)); 546 EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 547 old_types).Equals(disabled_types)); 548 } 549 550 // Test restarting the browser to newly supported datatypes. The new datatypes 551 // should be downloaded on the configuration after backend initialization. 552 TEST_F(SyncBackendHostTest, NewlySupportedTypes) { 553 sync_prefs_->SetSyncSetupCompleted(); 554 // Set sync manager behavior before passing it down. All types have progress 555 // markers and initial sync ended except the new types. 556 syncer::ModelTypeSet old_types = enabled_types_; 557 fake_manager_factory_->set_progress_marker_types(old_types); 558 fake_manager_factory_->set_initial_sync_ended_types(old_types); 559 syncer::ModelTypeSet new_types(syncer::APP_SETTINGS, 560 syncer::EXTENSION_SETTINGS); 561 enabled_types_.PutAll(new_types); 562 563 // Does nothing. 564 InitializeBackend(true); 565 EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Empty()); 566 EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(), 567 old_types).Empty()); 568 EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(old_types)); 569 EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 570 enabled_types_).Equals(new_types)); 571 572 // Downloads and applies the new types. 573 ConfigureDataTypes(enabled_types_, 574 Difference(syncer::ModelTypeSet::All(), 575 enabled_types_), 576 syncer::ModelTypeSet()); 577 EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals( 578 Union(new_types, syncer::ModelTypeSet(syncer::NIGORI)))); 579 EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(), 580 enabled_types_).Empty()); 581 EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_)); 582 EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_)); 583 EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 584 enabled_types_).Empty()); 585 } 586 587 // Test the newly supported types scenario, but with the presence of partial 588 // types as well. Both partial and newly supported types should be downloaded 589 // the configuration. 590 TEST_F(SyncBackendHostTest, NewlySupportedTypesWithPartialTypes) { 591 sync_prefs_->SetSyncSetupCompleted(); 592 // Set sync manager behavior before passing it down. All types have progress 593 // markers and initial sync ended except the new types. 594 syncer::ModelTypeSet old_types = enabled_types_; 595 syncer::ModelTypeSet partial_types(syncer::NIGORI, syncer::BOOKMARKS); 596 syncer::ModelTypeSet full_types = 597 Difference(enabled_types_, partial_types); 598 fake_manager_factory_->set_progress_marker_types(old_types); 599 fake_manager_factory_->set_initial_sync_ended_types(full_types); 600 syncer::ModelTypeSet new_types(syncer::APP_SETTINGS, 601 syncer::EXTENSION_SETTINGS); 602 enabled_types_.PutAll(new_types); 603 604 // Purge the partial types. The nigori will be among the purged types, but 605 // the syncer will re-download it by the time the initialization is complete. 606 InitializeBackend(true); 607 EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals( 608 syncer::ModelTypeSet(syncer::NIGORI))); 609 EXPECT_TRUE(fake_manager_->GetAndResetCleanedTypes().HasAll(partial_types)); 610 EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals( 611 syncer::Union(full_types, syncer::ModelTypeSet(syncer::NIGORI)))); 612 EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 613 enabled_types_).Equals(Union(new_types, Difference( 614 partial_types, syncer::ModelTypeSet(syncer::NIGORI))))); 615 616 // Downloads and applies the new types and partial types (which includes 617 // nigori anyways). 618 ConfigureDataTypes(enabled_types_, 619 Difference(syncer::ModelTypeSet::All(), 620 enabled_types_), 621 syncer::ModelTypeSet()); 622 EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals( 623 Union(new_types, partial_types))); 624 EXPECT_TRUE(Intersection(fake_manager_->GetAndResetCleanedTypes(), 625 enabled_types_).Empty()); 626 EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_)); 627 EXPECT_TRUE(fake_manager_->GetAndResetEnabledTypes().Equals(enabled_types_)); 628 EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 629 enabled_types_).Empty()); 630 } 631 632 // Verify that downloading control types only downloads those types that do 633 // not have initial sync ended set. 634 TEST_F(SyncBackendHostTest, DownloadControlTypes) { 635 sync_prefs_->SetSyncSetupCompleted(); 636 // Set sync manager behavior before passing it down. Experiments and device 637 // info are new types without progress markers or initial sync ended, while 638 // all other types have been fully downloaded and applied. 639 syncer::ModelTypeSet new_types(syncer::EXPERIMENTS, syncer::NIGORI); 640 syncer::ModelTypeSet old_types = 641 Difference(enabled_types_, new_types); 642 fake_manager_factory_->set_progress_marker_types(old_types); 643 fake_manager_factory_->set_initial_sync_ended_types(old_types); 644 645 // Bringing up the backend should download the new types without downloading 646 // any old types. 647 InitializeBackend(true); 648 EXPECT_TRUE(fake_manager_->GetAndResetDownloadedTypes().Equals(new_types)); 649 EXPECT_TRUE(fake_manager_->GetAndResetCleanedTypes().Equals( 650 Difference(syncer::ModelTypeSet::All(), 651 enabled_types_))); 652 EXPECT_TRUE(fake_manager_->InitialSyncEndedTypes().Equals(enabled_types_)); 653 EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 654 enabled_types_).Empty()); 655 } 656 657 // Fail to download control types. It's believed that there is a server bug 658 // which can allow this to happen (crbug.com/164288). The sync backend host 659 // should detect this condition and fail to initialize the backend. 660 // 661 // The failure is "silent" in the sense that the GetUpdates request appears to 662 // be successful, but it returned no results. This means that the usual 663 // download retry logic will not be invoked. 664 TEST_F(SyncBackendHostTest, SilentlyFailToDownloadControlTypes) { 665 fake_manager_factory_->set_configure_fail_types(syncer::ModelTypeSet::All()); 666 InitializeBackend(false); 667 } 668 669 // Test that local refresh requests are delivered to sync. 670 TEST_F(SyncBackendHostTest, ForwardLocalRefreshRequest) { 671 InitializeBackend(true); 672 673 syncer::ModelTypeSet set1 = syncer::ModelTypeSet::All(); 674 IssueRefreshRequest(set1); 675 fake_manager_->WaitForSyncThread(); 676 EXPECT_TRUE(set1.Equals(fake_manager_->GetLastRefreshRequestTypes())); 677 678 syncer::ModelTypeSet set2 = syncer::ModelTypeSet(syncer::SESSIONS); 679 IssueRefreshRequest(set2); 680 fake_manager_->WaitForSyncThread(); 681 EXPECT_TRUE(set2.Equals(fake_manager_->GetLastRefreshRequestTypes())); 682 } 683 684 // Test that local invalidations issued before sync is initialized are ignored. 685 TEST_F(SyncBackendHostTest, AttemptForwardLocalRefreshRequestEarly) { 686 syncer::ModelTypeSet set1 = syncer::ModelTypeSet::All(); 687 IssueRefreshRequest(set1); 688 689 InitializeBackend(true); 690 691 fake_manager_->WaitForSyncThread(); 692 EXPECT_FALSE(set1.Equals(fake_manager_->GetLastRefreshRequestTypes())); 693 } 694 695 // Test that local invalidations issued while sync is shutting down are ignored. 696 TEST_F(SyncBackendHostTest, AttemptForwardLocalRefreshRequestLate) { 697 InitializeBackend(true); 698 699 backend_->StopSyncingForShutdown(); 700 701 syncer::ModelTypeSet types = syncer::ModelTypeSet::All(); 702 IssueRefreshRequest(types); 703 fake_manager_->WaitForSyncThread(); 704 EXPECT_FALSE(types.Equals(fake_manager_->GetLastRefreshRequestTypes())); 705 706 backend_->Shutdown(syncer::STOP_SYNC); 707 backend_.reset(); 708 } 709 710 // Test that configuration on signin sends the proper GU source. 711 TEST_F(SyncBackendHostTest, DownloadControlTypesNewClient) { 712 InitializeBackend(true); 713 EXPECT_EQ(syncer::CONFIGURE_REASON_NEW_CLIENT, 714 fake_manager_->GetAndResetConfigureReason()); 715 } 716 717 // Test that configuration on restart sends the proper GU source. 718 TEST_F(SyncBackendHostTest, DownloadControlTypesRestart) { 719 sync_prefs_->SetSyncSetupCompleted(); 720 fake_manager_factory_->set_progress_marker_types(enabled_types_); 721 fake_manager_factory_->set_initial_sync_ended_types(enabled_types_); 722 InitializeBackend(true); 723 EXPECT_EQ(syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE, 724 fake_manager_->GetAndResetConfigureReason()); 725 } 726 727 // It is SyncBackendHostCore responsibility to cleanup Sync Data folder if sync 728 // setup hasn't been completed. This test ensures that cleanup happens. 729 TEST_F(SyncBackendHostTest, TestStartupWithOldSyncData) { 730 const char* nonsense = "slon"; 731 base::FilePath temp_directory = 732 profile_->GetPath().Append(base::FilePath(kTestSyncDir)); 733 base::FilePath sync_file = temp_directory.AppendASCII("SyncData.sqlite3"); 734 ASSERT_TRUE(base::CreateDirectory(temp_directory)); 735 ASSERT_NE(-1, base::WriteFile(sync_file, nonsense, strlen(nonsense))); 736 737 InitializeBackend(true); 738 739 EXPECT_FALSE(base::PathExists(sync_file)); 740 } 741 742 // If bookmarks encounter an error that results in disabling without purging 743 // (such as when the type is unready), and then is explicitly disabled, the 744 // SyncBackendHost needs to tell the manager to purge the type, even though 745 // it's already disabled (crbug.com/386778). 746 TEST_F(SyncBackendHostTest, DisableThenPurgeType) { 747 syncer::ModelTypeSet error_types(syncer::BOOKMARKS); 748 749 InitializeBackend(true); 750 751 // First enable the types. 752 ConfigureDataTypes(enabled_types_, 753 Difference(syncer::ModelTypeSet::All(), 754 enabled_types_), 755 syncer::ModelTypeSet()); 756 757 // Then mark the error types as unready (disables without purging). 758 ConfigureDataTypes(enabled_types_, 759 Difference(syncer::ModelTypeSet::All(), 760 enabled_types_), 761 error_types); 762 EXPECT_TRUE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 763 error_types).Empty()); 764 765 // Lastly explicitly disable the error types, which should result in a purge. 766 enabled_types_.RemoveAll(error_types); 767 ConfigureDataTypes(enabled_types_, 768 Difference(syncer::ModelTypeSet::All(), 769 enabled_types_), 770 syncer::ModelTypeSet()); 771 EXPECT_FALSE(fake_manager_->GetTypesWithEmptyProgressMarkerToken( 772 error_types).Empty()); 773 } 774 775 } // namespace 776 777 } // namespace browser_sync 778
