sync: Re-enable some migration integration tests

chrome/browser/sync/test/integration/migration_test.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_vector.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/backend_migrator.h"
 #include "chrome/browser/sync/profile_sync_service.h"
@@ skipping 225 matching lines @@
   // types.
   void AwaitMigration(syncer::ModelTypeSet migrate_types) {
     for (int i = 0; i < num_clients(); ++i) {
       MigrationChecker* checker = migration_checkers_[i];
       checker->set_expected_types(migrate_types);
       checker->Wait();
       ASSERT_FALSE(checker->TimedOut());
     }
   }
 
-  bool ShouldRunMigrationTest() const {
-    if (!ServerSupportsNotificationControl() ||
-        !ServerSupportsErrorTriggering()) {
-      LOG(WARNING) << "Test skipped in this server environment.";
-      return false;
-    }
-    return true;
-  }
-
   // Makes sure migration works with the given migration list and
   // trigger method.
   void RunMigrationTest(const MigrationList& migration_list,
                         TriggerMethod trigger_method) {
-    ASSERT_TRUE(ShouldRunMigrationTest());
-
     // If we have only one client, turn off notifications to avoid the
     // possibility of spurious sync cycles.
     bool do_test_without_notifications =
         (trigger_method != TRIGGER_NOTIFICATION && num_clients() == 1);
 
     if (do_test_without_notifications) {
       DisableNotifications();
     }
 
     // Make sure migration hasn't been triggered prematurely.
@@ skipping 35 matching lines @@
 
  private:
   // Used to keep track of the migration progress for each sync client.
   ScopedVector<MigrationChecker> migration_checkers_;
 
   DISALLOW_COPY_AND_ASSIGN(MigrationTest);
 };
 
 class MigrationSingleClientTest : public MigrationTest {
  public:
-  MigrationSingleClientTest() : MigrationTest(SINGLE_CLIENT) {}
+  MigrationSingleClientTest() : MigrationTest(SINGLE_CLIENT_LEGACY) {}
   virtual ~MigrationSingleClientTest() {}
 
   void RunSingleClientMigrationTest(const MigrationList& migration_list,
                                     TriggerMethod trigger_method) {
-    if (!ShouldRunMigrationTest()) {
-      return;
-    }
     ASSERT_TRUE(SetupSync());
     RunMigrationTest(migration_list, trigger_method);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MigrationSingleClientTest);
 };
 
 // The simplest possible migration tests -- a single data type.
 
@@ skipping 14 matching lines @@
 
 // Nigori is handled specially, so we test that separately.
 
 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, NigoriOnly) {
   RunSingleClientMigrationTest(MakeList(syncer::PREFERENCES),
                                TRIGGER_NOTIFICATION);
 }
 
 // A little more complicated -- two data types.
 
+// See crbug.com/392989.
 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
-                       BookmarksPrefsIndividually) {
+                       DISABLED_BookmarksPrefsIndividually) {
   RunSingleClientMigrationTest(
       MakeList(syncer::BOOKMARKS, syncer::PREFERENCES),
       MODIFY_PREF);
 }
 
 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, BookmarksPrefsBoth) {
   RunSingleClientMigrationTest(
       MakeList(MakeSet(syncer::BOOKMARKS, syncer::PREFERENCES)),
       MODIFY_BOOKMARK);
 }
 
 // Two data types with one being nigori.
 
 // See crbug.com/124480.
 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
                        DISABLED_PrefsNigoriIndividiaully) {
   RunSingleClientMigrationTest(
       MakeList(syncer::PREFERENCES, syncer::NIGORI),
       TRIGGER_NOTIFICATION);
 }
 
 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, PrefsNigoriBoth) {
   RunSingleClientMigrationTest(
       MakeList(MakeSet(syncer::PREFERENCES, syncer::NIGORI)),
       MODIFY_PREF);
 }
 
 // The whole shebang -- all data types.
 
-IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, AllTypesIndividually) {
+// See crbug.com/392989.
+IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
+                       DISABLED_AllTypesIndividually) {
   ASSERT_TRUE(SetupClients());
   RunSingleClientMigrationTest(GetPreferredDataTypesList(), MODIFY_BOOKMARK);
 }
 
+// See crbug.com/392989.
 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
-                       AllTypesIndividuallyTriggerNotification) {
+                       DISABLED_AllTypesIndividuallyTriggerNotification) {
   ASSERT_TRUE(SetupClients());
   RunSingleClientMigrationTest(GetPreferredDataTypesList(),
                                TRIGGER_NOTIFICATION);
 }
 
-IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, AllTypesAtOnce) {
+// See crbug.com/392989.
+IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, DISABLED_AllTypesAtOnce) {
   ASSERT_TRUE(SetupClients());
   RunSingleClientMigrationTest(MakeList(GetPreferredDataTypes()),
                                MODIFY_PREF);
 }
 
+// See crbug.com/392989.
 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
-                       AllTypesAtOnceTriggerNotification) {
+                       DISABLED_AllTypesAtOnceTriggerNotification) {
   ASSERT_TRUE(SetupClients());
   RunSingleClientMigrationTest(MakeList(GetPreferredDataTypes()),
                                TRIGGER_NOTIFICATION);
 }
 
 // All data types plus nigori.
 
 // See crbug.com/124480.
 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
                        DISABLED_AllTypesWithNigoriIndividually) {
   ASSERT_TRUE(SetupClients());
   MigrationList migration_list = GetPreferredDataTypesList();
   migration_list.push_front(MakeSet(syncer::NIGORI));
   RunSingleClientMigrationTest(migration_list, MODIFY_BOOKMARK);
 }
 
+// See crbug.com/392989.
 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
-                       AllTypesWithNigoriAtOnce) {
+                       DISABLED_AllTypesWithNigoriAtOnce) {
   ASSERT_TRUE(SetupClients());
   syncer::ModelTypeSet all_types = GetPreferredDataTypes();
   all_types.Put(syncer::NIGORI);
   RunSingleClientMigrationTest(MakeList(all_types), MODIFY_PREF);
 }
 
 class MigrationTwoClientTest : public MigrationTest {
  public:
-  MigrationTwoClientTest() : MigrationTest(TWO_CLIENT) {}
+  MigrationTwoClientTest() : MigrationTest(TWO_CLIENT_LEGACY) {}
   virtual ~MigrationTwoClientTest() {}
 
   // Helper function that verifies that preferences sync still works.
   void VerifyPrefSync() {
     ASSERT_TRUE(BooleanPrefMatches(prefs::kShowHomeButton));
     ChangeBooleanPref(0, prefs::kShowHomeButton);
     ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
     ASSERT_TRUE(BooleanPrefMatches(prefs::kShowHomeButton));
   }
 
   void RunTwoClientMigrationTest(const MigrationList& migration_list,
                                  TriggerMethod trigger_method) {
-    if (!ShouldRunMigrationTest()) {
-      return;
-    }
     ASSERT_TRUE(SetupSync());
 
     // Make sure pref sync works before running the migration test.
     VerifyPrefSync();
 
     RunMigrationTest(migration_list, trigger_method);
 
     // Make sure pref sync still works after running the migration
     // test.
     VerifyPrefSync();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MigrationTwoClientTest);
 };
 
 // Easiest possible test of migration errors: triggers a server
 // migration on one datatype, then modifies some other datatype.
-IN_PROC_BROWSER_TEST_F(MigrationTwoClientTest, MigratePrefsThenModifyBookmark) {
+// See crbug.com/392989.
+IN_PROC_BROWSER_TEST_F(MigrationTwoClientTest,
+                       DISABLED_MigratePrefsThenModifyBookmark) {
   RunTwoClientMigrationTest(MakeList(syncer::PREFERENCES),
                             MODIFY_BOOKMARK);
 }
 
 // Triggers a server migration on two datatypes, then makes a local
 // modification to one of them.
+// See crbug.com/392989.
 IN_PROC_BROWSER_TEST_F(MigrationTwoClientTest,
-                       MigratePrefsAndBookmarksThenModifyBookmark) {
+                       DISABLED_MigratePrefsAndBookmarksThenModifyBookmark) {
   RunTwoClientMigrationTest(
       MakeList(syncer::PREFERENCES, syncer::BOOKMARKS),
       MODIFY_BOOKMARK);
 }
 
 // Migrate every datatype in sequence; the catch being that the server
 // will only tell the client about the migrations one at a time.
 // TODO(rsimha): This test takes longer than 60 seconds, and will cause tree
 // redness due to sharding.
 // Re-enable this test after syncer::kInitialBackoffShortRetrySeconds is reduced
@@ skipping 33 matching lines @@
     // Do not add optional datatypes.
   }
 
   virtual ~MigrationReconfigureTest() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MigrationReconfigureTest);
 };
 
 }  // namespace