1 // Copyright 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/compiler_specific.h" 6 #include "base/memory/scoped_vector.h" 7 #include "base/prefs/scoped_user_pref_update.h" 8 #include "chrome/browser/profiles/profile.h" 9 #include "chrome/browser/sync/backend_migrator.h" 10 #include "chrome/browser/sync/profile_sync_service.h" 11 #include "chrome/browser/sync/test/integration/bookmarks_helper.h" 12 #include "chrome/browser/sync/test/integration/preferences_helper.h" 13 #include "chrome/browser/sync/test/integration/profile_sync_service_harness.h" 14 #include "chrome/browser/sync/test/integration/single_client_status_change_checker.h" 15 #include "chrome/browser/sync/test/integration/sync_test.h" 16 #include "chrome/common/pref_names.h" 17 #include "chrome/test/base/ui_test_utils.h" 18 #include "components/translate/core/browser/translate_prefs.h" 19 20 using bookmarks_helper::AddURL; 21 using bookmarks_helper::IndexedURL; 22 using bookmarks_helper::IndexedURLTitle; 23 24 using preferences_helper::BooleanPrefMatches; 25 using preferences_helper::ChangeBooleanPref; 26 27 namespace { 28 29 // Utility functions to make a model type set out of a small number of 30 // model types. 31 32 syncer::ModelTypeSet MakeSet(syncer::ModelType type) { 33 return syncer::ModelTypeSet(type); 34 } 35 36 syncer::ModelTypeSet MakeSet(syncer::ModelType type1, 37 syncer::ModelType type2) { 38 return syncer::ModelTypeSet(type1, type2); 39 } 40 41 // An ordered list of model types sets to migrate. Used by 42 // RunMigrationTest(). 43 typedef std::deque<syncer::ModelTypeSet> MigrationList; 44 45 // Utility functions to make a MigrationList out of a small number of 46 // model types / model type sets. 47 48 MigrationList MakeList(syncer::ModelTypeSet model_types) { 49 return MigrationList(1, model_types); 50 } 51 52 MigrationList MakeList(syncer::ModelTypeSet model_types1, 53 syncer::ModelTypeSet model_types2) { 54 MigrationList migration_list; 55 migration_list.push_back(model_types1); 56 migration_list.push_back(model_types2); 57 return migration_list; 58 } 59 60 MigrationList MakeList(syncer::ModelType type) { 61 return MakeList(MakeSet(type)); 62 } 63 64 MigrationList MakeList(syncer::ModelType type1, 65 syncer::ModelType type2) { 66 return MakeList(MakeSet(type1), MakeSet(type2)); 67 } 68 69 // Helper class that checks if the sync backend has successfully completed 70 // migration for a set of data types. 71 class MigrationChecker : public SingleClientStatusChangeChecker, 72 public browser_sync::MigrationObserver { 73 public: 74 explicit MigrationChecker(ProfileSyncServiceHarness* harness) 75 : SingleClientStatusChangeChecker(harness->service()), 76 harness_(harness) { 77 DCHECK(harness_); 78 browser_sync::BackendMigrator* migrator = 79 harness_->service()->GetBackendMigratorForTest(); 80 // PSS must have a migrator after sync is setup and initial data type 81 // configuration is complete. 82 DCHECK(migrator); 83 migrator->AddMigrationObserver(this); 84 } 85 86 virtual ~MigrationChecker() {} 87 88 // Returns true when sync reports that there is no pending migration, and 89 // migration is complete for all data types in |expected_types_|. 90 virtual bool IsExitConditionSatisfied() OVERRIDE { 91 DCHECK(!expected_types_.Empty()); 92 bool all_expected_types_migrated = migrated_types_.HasAll(expected_types_); 93 DVLOG(1) << harness_->profile_debug_name() << ": Migrated types " 94 << syncer::ModelTypeSetToString(migrated_types_) 95 << (all_expected_types_migrated ? " contains " : 96 " does not contain ") 97 << syncer::ModelTypeSetToString(expected_types_); 98 return all_expected_types_migrated && 99 !HasPendingBackendMigration(); 100 } 101 102 virtual std::string GetDebugMessage() const OVERRIDE { 103 return "Waiting to migrate (" + ModelTypeSetToString(expected_types_) + ")"; 104 } 105 106 bool HasPendingBackendMigration() const { 107 browser_sync::BackendMigrator* migrator = 108 harness_->service()->GetBackendMigratorForTest(); 109 return migrator && migrator->state() != browser_sync::BackendMigrator::IDLE; 110 } 111 112 void set_expected_types(syncer::ModelTypeSet expected_types) { 113 expected_types_ = expected_types; 114 } 115 116 syncer::ModelTypeSet migrated_types() const { 117 return migrated_types_; 118 } 119 120 virtual void OnMigrationStateChange() OVERRIDE { 121 if (HasPendingBackendMigration()) { 122 // A new bunch of data types are in the process of being migrated. Merge 123 // them into |pending_types_|. 124 pending_types_.PutAll( 125 harness_->service()->GetBackendMigratorForTest()-> 126 GetPendingMigrationTypesForTest()); 127 DVLOG(1) << harness_->profile_debug_name() 128 << ": new pending migration types " 129 << syncer::ModelTypeSetToString(pending_types_); 130 } else { 131 // Migration just finished for a bunch of data types. Merge them into 132 // |migrated_types_|. 133 migrated_types_.PutAll(pending_types_); 134 pending_types_.Clear(); 135 DVLOG(1) << harness_->profile_debug_name() << ": new migrated types " 136 << syncer::ModelTypeSetToString(migrated_types_); 137 } 138 139 // Manually trigger a check of the exit condition. 140 if (!expected_types_.Empty()) 141 OnStateChanged(); 142 } 143 144 private: 145 // The sync client for which migration is being verified. 146 ProfileSyncServiceHarness* harness_; 147 148 // The set of data types that are expected to eventually undergo migration. 149 syncer::ModelTypeSet expected_types_; 150 151 // The set of data types currently undergoing migration. 152 syncer::ModelTypeSet pending_types_; 153 154 // The set of data types for which migration is complete. Accumulated by 155 // successive calls to OnMigrationStateChanged. 156 syncer::ModelTypeSet migrated_types_; 157 158 DISALLOW_COPY_AND_ASSIGN(MigrationChecker); 159 }; 160 161 class MigrationTest : public SyncTest { 162 public: 163 explicit MigrationTest(TestType test_type) : SyncTest(test_type) {} 164 virtual ~MigrationTest() {} 165 166 enum TriggerMethod { MODIFY_PREF, MODIFY_BOOKMARK, TRIGGER_NOTIFICATION }; 167 168 // Set up sync for all profiles and initialize all MigrationCheckers. This 169 // helps ensure that all migration events are captured, even if they were to 170 // occur before a test calls AwaitMigration for a specific profile. 171 virtual bool SetupSync() OVERRIDE { 172 if (!SyncTest::SetupSync()) 173 return false; 174 175 for (int i = 0; i < num_clients(); ++i) { 176 MigrationChecker* checker = new MigrationChecker(GetClient(i)); 177 migration_checkers_.push_back(checker); 178 } 179 return true; 180 } 181 182 syncer::ModelTypeSet GetPreferredDataTypes() { 183 // ProfileSyncService must already have been created before we can call 184 // GetPreferredDataTypes(). 185 DCHECK(GetSyncService((0))); 186 syncer::ModelTypeSet preferred_data_types = 187 GetSyncService((0))->GetPreferredDataTypes(); 188 preferred_data_types.RemoveAll(syncer::ProxyTypes()); 189 // Make sure all clients have the same preferred data types. 190 for (int i = 1; i < num_clients(); ++i) { 191 const syncer::ModelTypeSet other_preferred_data_types = 192 GetSyncService((i))->GetPreferredDataTypes(); 193 EXPECT_TRUE(preferred_data_types.Equals(other_preferred_data_types)); 194 } 195 return preferred_data_types; 196 } 197 198 // Returns a MigrationList with every enabled data type in its own 199 // set. 200 MigrationList GetPreferredDataTypesList() { 201 MigrationList migration_list; 202 const syncer::ModelTypeSet preferred_data_types = 203 GetPreferredDataTypes(); 204 for (syncer::ModelTypeSet::Iterator it = 205 preferred_data_types.First(); it.Good(); it.Inc()) { 206 migration_list.push_back(MakeSet(it.Get())); 207 } 208 return migration_list; 209 } 210 211 // Trigger a migration for the given types with the given method. 212 void TriggerMigration(syncer::ModelTypeSet model_types, 213 TriggerMethod trigger_method) { 214 switch (trigger_method) { 215 case MODIFY_PREF: 216 // Unlike MODIFY_BOOKMARK, MODIFY_PREF doesn't cause a 217 // notification to happen (since model association on a 218 // boolean pref clobbers the local value), so it doesn't work 219 // for anything but single-client tests. 220 ASSERT_EQ(1, num_clients()); 221 ASSERT_TRUE(BooleanPrefMatches(prefs::kShowHomeButton)); 222 ChangeBooleanPref(0, prefs::kShowHomeButton); 223 break; 224 case MODIFY_BOOKMARK: 225 ASSERT_TRUE(AddURL(0, IndexedURLTitle(0), GURL(IndexedURL(0)))); 226 break; 227 case TRIGGER_NOTIFICATION: 228 TriggerNotification(model_types); 229 break; 230 default: 231 ADD_FAILURE(); 232 } 233 } 234 235 // Block until all clients have completed migration for the given 236 // types. 237 void AwaitMigration(syncer::ModelTypeSet migrate_types) { 238 for (int i = 0; i < num_clients(); ++i) { 239 MigrationChecker* checker = migration_checkers_[i]; 240 checker->set_expected_types(migrate_types); 241 checker->Wait(); 242 ASSERT_FALSE(checker->TimedOut()); 243 } 244 } 245 246 bool ShouldRunMigrationTest() const { 247 if (!ServerSupportsNotificationControl() || 248 !ServerSupportsErrorTriggering()) { 249 LOG(WARNING) << "Test skipped in this server environment."; 250 return false; 251 } 252 return true; 253 } 254 255 // Makes sure migration works with the given migration list and 256 // trigger method. 257 void RunMigrationTest(const MigrationList& migration_list, 258 TriggerMethod trigger_method) { 259 ASSERT_TRUE(ShouldRunMigrationTest()); 260 261 // If we have only one client, turn off notifications to avoid the 262 // possibility of spurious sync cycles. 263 bool do_test_without_notifications = 264 (trigger_method != TRIGGER_NOTIFICATION && num_clients() == 1); 265 266 if (do_test_without_notifications) { 267 DisableNotifications(); 268 } 269 270 // Make sure migration hasn't been triggered prematurely. 271 for (int i = 0; i < num_clients(); ++i) { 272 ASSERT_TRUE(migration_checkers_[i]->migrated_types().Empty()); 273 } 274 275 // Phase 1: Trigger the migrations on the server. 276 for (MigrationList::const_iterator it = migration_list.begin(); 277 it != migration_list.end(); ++it) { 278 TriggerMigrationDoneError(*it); 279 } 280 281 // Phase 2: Trigger each migration individually and wait for it to 282 // complete. (Multiple migrations may be handled by each 283 // migration cycle, but there's no guarantee of that, so we have 284 // to trigger each migration individually.) 285 for (MigrationList::const_iterator it = migration_list.begin(); 286 it != migration_list.end(); ++it) { 287 TriggerMigration(*it, trigger_method); 288 AwaitMigration(*it); 289 } 290 291 // Phase 3: Wait for all clients to catch up. 292 // 293 // AwaitQuiescence() will not succeed when notifications are disabled. We 294 // can safely avoid calling it because we know that, in the single client 295 // case, there is no one else to wait for. 296 // 297 // TODO(rlarocque, 97780): Remove the if condition when the test harness 298 // supports calling AwaitQuiescence() when notifications are disabled. 299 if (!do_test_without_notifications) { 300 AwaitQuiescence(); 301 } 302 303 // TODO(rlarocque): It should be possible to re-enable notifications 304 // here, but doing so makes some windows tests flaky. 305 } 306 307 private: 308 // Used to keep track of the migration progress for each sync client. 309 ScopedVector<MigrationChecker> migration_checkers_; 310 311 DISALLOW_COPY_AND_ASSIGN(MigrationTest); 312 }; 313 314 class MigrationSingleClientTest : public MigrationTest { 315 public: 316 MigrationSingleClientTest() : MigrationTest(SINGLE_CLIENT) {} 317 virtual ~MigrationSingleClientTest() {} 318 319 void RunSingleClientMigrationTest(const MigrationList& migration_list, 320 TriggerMethod trigger_method) { 321 if (!ShouldRunMigrationTest()) { 322 return; 323 } 324 ASSERT_TRUE(SetupSync()); 325 RunMigrationTest(migration_list, trigger_method); 326 } 327 328 private: 329 DISALLOW_COPY_AND_ASSIGN(MigrationSingleClientTest); 330 }; 331 332 // The simplest possible migration tests -- a single data type. 333 334 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, PrefsOnlyModifyPref) { 335 RunSingleClientMigrationTest(MakeList(syncer::PREFERENCES), MODIFY_PREF); 336 } 337 338 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, PrefsOnlyModifyBookmark) { 339 RunSingleClientMigrationTest(MakeList(syncer::PREFERENCES), 340 MODIFY_BOOKMARK); 341 } 342 343 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, 344 PrefsOnlyTriggerNotification) { 345 RunSingleClientMigrationTest(MakeList(syncer::PREFERENCES), 346 TRIGGER_NOTIFICATION); 347 } 348 349 // Nigori is handled specially, so we test that separately. 350 351 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, NigoriOnly) { 352 RunSingleClientMigrationTest(MakeList(syncer::PREFERENCES), 353 TRIGGER_NOTIFICATION); 354 } 355 356 // A little more complicated -- two data types. 357 358 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, 359 BookmarksPrefsIndividually) { 360 RunSingleClientMigrationTest( 361 MakeList(syncer::BOOKMARKS, syncer::PREFERENCES), 362 MODIFY_PREF); 363 } 364 365 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, BookmarksPrefsBoth) { 366 RunSingleClientMigrationTest( 367 MakeList(MakeSet(syncer::BOOKMARKS, syncer::PREFERENCES)), 368 MODIFY_BOOKMARK); 369 } 370 371 // Two data types with one being nigori. 372 373 // See crbug.com/124480. 374 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, 375 DISABLED_PrefsNigoriIndividiaully) { 376 RunSingleClientMigrationTest( 377 MakeList(syncer::PREFERENCES, syncer::NIGORI), 378 TRIGGER_NOTIFICATION); 379 } 380 381 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, PrefsNigoriBoth) { 382 RunSingleClientMigrationTest( 383 MakeList(MakeSet(syncer::PREFERENCES, syncer::NIGORI)), 384 MODIFY_PREF); 385 } 386 387 // The whole shebang -- all data types. 388 389 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, AllTypesIndividually) { 390 ASSERT_TRUE(SetupClients()); 391 RunSingleClientMigrationTest(GetPreferredDataTypesList(), MODIFY_BOOKMARK); 392 } 393 394 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, 395 AllTypesIndividuallyTriggerNotification) { 396 ASSERT_TRUE(SetupClients()); 397 RunSingleClientMigrationTest(GetPreferredDataTypesList(), 398 TRIGGER_NOTIFICATION); 399 } 400 401 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, AllTypesAtOnce) { 402 ASSERT_TRUE(SetupClients()); 403 RunSingleClientMigrationTest(MakeList(GetPreferredDataTypes()), 404 MODIFY_PREF); 405 } 406 407 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, 408 AllTypesAtOnceTriggerNotification) { 409 ASSERT_TRUE(SetupClients()); 410 RunSingleClientMigrationTest(MakeList(GetPreferredDataTypes()), 411 TRIGGER_NOTIFICATION); 412 } 413 414 // All data types plus nigori. 415 416 // See crbug.com/124480. 417 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, 418 DISABLED_AllTypesWithNigoriIndividually) { 419 ASSERT_TRUE(SetupClients()); 420 MigrationList migration_list = GetPreferredDataTypesList(); 421 migration_list.push_front(MakeSet(syncer::NIGORI)); 422 RunSingleClientMigrationTest(migration_list, MODIFY_BOOKMARK); 423 } 424 425 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, 426 AllTypesWithNigoriAtOnce) { 427 ASSERT_TRUE(SetupClients()); 428 syncer::ModelTypeSet all_types = GetPreferredDataTypes(); 429 all_types.Put(syncer::NIGORI); 430 RunSingleClientMigrationTest(MakeList(all_types), MODIFY_PREF); 431 } 432 433 class MigrationTwoClientTest : public MigrationTest { 434 public: 435 MigrationTwoClientTest() : MigrationTest(TWO_CLIENT) {} 436 virtual ~MigrationTwoClientTest() {} 437 438 // Helper function that verifies that preferences sync still works. 439 void VerifyPrefSync() { 440 ASSERT_TRUE(BooleanPrefMatches(prefs::kShowHomeButton)); 441 ChangeBooleanPref(0, prefs::kShowHomeButton); 442 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1))); 443 ASSERT_TRUE(BooleanPrefMatches(prefs::kShowHomeButton)); 444 } 445 446 void RunTwoClientMigrationTest(const MigrationList& migration_list, 447 TriggerMethod trigger_method) { 448 if (!ShouldRunMigrationTest()) { 449 return; 450 } 451 ASSERT_TRUE(SetupSync()); 452 453 // Make sure pref sync works before running the migration test. 454 VerifyPrefSync(); 455 456 RunMigrationTest(migration_list, trigger_method); 457 458 // Make sure pref sync still works after running the migration 459 // test. 460 VerifyPrefSync(); 461 } 462 463 private: 464 DISALLOW_COPY_AND_ASSIGN(MigrationTwoClientTest); 465 }; 466 467 // Easiest possible test of migration errors: triggers a server 468 // migration on one datatype, then modifies some other datatype. 469 IN_PROC_BROWSER_TEST_F(MigrationTwoClientTest, MigratePrefsThenModifyBookmark) { 470 RunTwoClientMigrationTest(MakeList(syncer::PREFERENCES), 471 MODIFY_BOOKMARK); 472 } 473 474 // Triggers a server migration on two datatypes, then makes a local 475 // modification to one of them. 476 IN_PROC_BROWSER_TEST_F(MigrationTwoClientTest, 477 MigratePrefsAndBookmarksThenModifyBookmark) { 478 RunTwoClientMigrationTest( 479 MakeList(syncer::PREFERENCES, syncer::BOOKMARKS), 480 MODIFY_BOOKMARK); 481 } 482 483 // Migrate every datatype in sequence; the catch being that the server 484 // will only tell the client about the migrations one at a time. 485 // TODO(rsimha): This test takes longer than 60 seconds, and will cause tree 486 // redness due to sharding. 487 // Re-enable this test after syncer::kInitialBackoffShortRetrySeconds is reduced 488 // to zero. 489 IN_PROC_BROWSER_TEST_F(MigrationTwoClientTest, 490 DISABLED_MigrationHellWithoutNigori) { 491 ASSERT_TRUE(SetupClients()); 492 MigrationList migration_list = GetPreferredDataTypesList(); 493 // Let the first nudge be a datatype that's neither prefs nor 494 // bookmarks. 495 migration_list.push_front(MakeSet(syncer::THEMES)); 496 RunTwoClientMigrationTest(migration_list, MODIFY_BOOKMARK); 497 } 498 499 // See crbug.com/124480. 500 IN_PROC_BROWSER_TEST_F(MigrationTwoClientTest, 501 DISABLED_MigrationHellWithNigori) { 502 ASSERT_TRUE(SetupClients()); 503 MigrationList migration_list = GetPreferredDataTypesList(); 504 // Let the first nudge be a datatype that's neither prefs nor 505 // bookmarks. 506 migration_list.push_front(MakeSet(syncer::THEMES)); 507 // Pop off one so that we don't migrate all data types; the syncer 508 // freaks out if we do that (see http://crbug.com/94882). 509 ASSERT_GE(migration_list.size(), 2u); 510 ASSERT_FALSE(migration_list.back().Equals(MakeSet(syncer::NIGORI))); 511 migration_list.back() = MakeSet(syncer::NIGORI); 512 RunTwoClientMigrationTest(migration_list, MODIFY_BOOKMARK); 513 } 514 515 class MigrationReconfigureTest : public MigrationTwoClientTest { 516 public: 517 MigrationReconfigureTest() {} 518 519 virtual void SetUpCommandLine(base::CommandLine* cl) OVERRIDE { 520 AddTestSwitches(cl); 521 // Do not add optional datatypes. 522 } 523 524 virtual ~MigrationReconfigureTest() {} 525 526 private: 527 DISALLOW_COPY_AND_ASSIGN(MigrationReconfigureTest); 528 }; 529 530 } // namespace 531