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