[Sync] Refactoring of sync integration test checkers to remove boilerplate await methods.

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

 // Copyright (c) 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 <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/rand_util.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/policy/profile_policy_connector_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/test/integration/bookmarks_helper.h"
 #include "chrome/browser/sync/test/integration/profile_sync_service_harness.h"
 #include "chrome/browser/sync/test/integration/sync_integration_test_util.h"
 #include "chrome/browser/sync/test/integration/sync_test.h"
+#include "chrome/browser/sync/test/integration/updated_progress_marker_checker.h"
 #include "components/bookmarks/browser/bookmark_node.h"
 #include "components/browser_sync/profile_sync_service.h"
 #include "components/policy/core/common/mock_configuration_policy_provider.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/core/common/policy_types.h"
 #include "components/policy/policy_constants.h"
 #include "components/sync/driver/sync_service.h"
 #include "components/sync/engine/cycle/sync_cycle_snapshot.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "ui/base/layout.h"
 
 using bookmarks::BookmarkNode;
 using bookmarks_helper::AddFolder;
 using bookmarks_helper::AddURL;
 using bookmarks_helper::AllModelsMatch;
 using bookmarks_helper::AllModelsMatchVerifier;
-using bookmarks_helper::AwaitAllModelsMatch;
 using bookmarks_helper::CheckFaviconExpired;
 using bookmarks_helper::ContainsDuplicateBookmarks;
 using bookmarks_helper::CountAllBookmarks;
 using bookmarks_helper::CountBookmarksWithTitlesMatching;
 using bookmarks_helper::CountBookmarksWithUrlsMatching;
 using bookmarks_helper::CountFoldersWithTitlesMatching;
 using bookmarks_helper::CreateFavicon;
 using bookmarks_helper::ExpireFavicon;
 using bookmarks_helper::GetBookmarkBarNode;
 using bookmarks_helper::GetManagedNode;
 using bookmarks_helper::GetOtherNode;
 using bookmarks_helper::GetSyncedBookmarksNode;
 using bookmarks_helper::GetUniqueNodeByURL;
 using bookmarks_helper::HasNodeWithURL;
 using bookmarks_helper::IndexedFolderName;
 using bookmarks_helper::IndexedSubfolderName;
 using bookmarks_helper::IndexedSubsubfolderName;
 using bookmarks_helper::IndexedURL;
 using bookmarks_helper::IndexedURLTitle;
 using bookmarks_helper::Move;
 using bookmarks_helper::Remove;
 using bookmarks_helper::RemoveAll;
 using bookmarks_helper::ReverseChildOrder;
 using bookmarks_helper::SetFavicon;
 using bookmarks_helper::SetTitle;
 using bookmarks_helper::SetURL;
 using bookmarks_helper::SortChildren;
-using sync_integration_test_util::AwaitCommitActivityCompletion;
-using sync_integration_test_util::AwaitPassphraseAccepted;
-using sync_integration_test_util::AwaitPassphraseRequired;
 
 namespace {
 
 const char kGenericURL[] = "http://www.host.ext:1234/path/filename";
 const char kGenericURLTitle[] = "URL Title";
 const char kGenericFolderName[] = "Folder Name";
 const char kGenericSubfolderName[] = "Subfolder Name";
 const char kValidPassphrase[] = "passphrase!";
 
 }  // namespace
@@ skipping 1633 matching lines @@
   ASSERT_TRUE(AllModelsMatch());
 }
 
 // TCM ID - 7343544.
 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, DisableSync) {
   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
   ASSERT_TRUE(AllModelsMatchVerifier());
 
   ASSERT_TRUE(GetClient(1)->DisableSyncForAllDatatypes());
   ASSERT_TRUE(AddFolder(0, IndexedFolderName(0)) != NULL);
-  ASSERT_TRUE(AwaitCommitActivityCompletion(GetSyncService(0)));
+  ASSERT_TRUE(UpdatedProgressMarkerChecker(GetSyncService(0)).Wait());
   ASSERT_FALSE(AllModelsMatch());
 
   ASSERT_TRUE(AddFolder(1, IndexedFolderName(1)) != NULL);
   ASSERT_FALSE(AllModelsMatch());
 
   ASSERT_TRUE(GetClient(1)->EnableSyncForAllDatatypes());
   ASSERT_TRUE(AwaitQuiescence());
   ASSERT_TRUE(AllModelsMatch());
 }
 
@@ skipping 26 matching lines @@
 IN_PROC_BROWSER_TEST_F(LegacyTwoClientBookmarksSyncTest, MC_DeleteBookmark) {
   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
   ASSERT_TRUE(GetClient(1)->DisableSyncForDatatype(syncer::BOOKMARKS));
 
   const GURL bar_url("http://example.com/bar");
   const GURL other_url("http://example.com/other");
 
   ASSERT_TRUE(AddURL(0, GetBookmarkBarNode(0), 0, "bar", bar_url) != NULL);
   ASSERT_TRUE(AddURL(0, GetOtherNode(0), 0, "other", other_url) != NULL);
 
-  ASSERT_TRUE(AwaitCommitActivityCompletion(GetSyncService(0)));
+  ASSERT_TRUE(UpdatedProgressMarkerChecker(GetSyncService(0)).Wait());
 
   ASSERT_TRUE(HasNodeWithURL(0, bar_url));
   ASSERT_TRUE(HasNodeWithURL(0, other_url));
   ASSERT_FALSE(HasNodeWithURL(1, bar_url));
   ASSERT_FALSE(HasNodeWithURL(1, other_url));
 
   Remove(0, GetBookmarkBarNode(0), 0);
-  ASSERT_TRUE(AwaitCommitActivityCompletion(GetSyncService(0)));
+  ASSERT_TRUE(UpdatedProgressMarkerChecker(GetSyncService(0)).Wait());
 
   ASSERT_FALSE(HasNodeWithURL(0, bar_url));
   ASSERT_TRUE(HasNodeWithURL(0, other_url));
 
   ASSERT_TRUE(GetClient(1)->EnableSyncForDatatype(syncer::BOOKMARKS));
   ASSERT_TRUE(AwaitQuiescence());
 
   ASSERT_FALSE(HasNodeWithURL(0, bar_url));
   ASSERT_TRUE(HasNodeWithURL(0, other_url));
   ASSERT_FALSE(HasNodeWithURL(1, bar_url));
@@ skipping 209 matching lines @@
   ASSERT_TRUE(AddURL(0, 0, IndexedURLTitle(0), GURL(IndexedURL(0))) != NULL);
   ASSERT_TRUE(AddURL(0, 1, IndexedURLTitle(1), GURL(IndexedURL(1))) != NULL);
   ASSERT_TRUE(AddURL(0, 2, IndexedURLTitle(2), GURL(IndexedURL(2))) != NULL);
   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
   ASSERT_TRUE(AllModelsMatchVerifier());
 
   // Set a passphrase and enable encryption on Client 0. Client 1 will not
   // understand the bookmark updates.
   GetSyncService(0)->SetEncryptionPassphrase(
       kValidPassphrase, sync_driver::SyncService::EXPLICIT);
-  ASSERT_TRUE(AwaitPassphraseAccepted(GetSyncService(0)));
+  ASSERT_TRUE(PassphraseAcceptedChecker(GetSyncService(0)).Wait());
   ASSERT_TRUE(EnableEncryption(0));
   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
   ASSERT_TRUE(IsEncryptionComplete(0));
   ASSERT_TRUE(IsEncryptionComplete(1));
   ASSERT_TRUE(GetSyncService(1)->IsPassphraseRequired());
 
   // Client 1 adds bookmarks between the first two and between the second two.
   ASSERT_TRUE(AddURL(0, 1, IndexedURLTitle(3), GURL(IndexedURL(3))) != NULL);
   ASSERT_TRUE(AddURL(0, 3, IndexedURLTitle(4), GURL(IndexedURL(4))) != NULL);
   EXPECT_FALSE(AllModelsMatchVerifier());
   EXPECT_FALSE(AllModelsMatch());
 
   // Set the passphrase. Everything should resolve.
-  ASSERT_TRUE(AwaitPassphraseRequired(GetSyncService(1)));
+  ASSERT_TRUE(PassphraseRequiredChecker(GetSyncService(1)).Wait());
   ASSERT_TRUE(GetSyncService(1)->SetDecryptionPassphrase(kValidPassphrase));
-  ASSERT_TRUE(AwaitPassphraseAccepted(GetSyncService(1)));
+  ASSERT_TRUE(PassphraseAcceptedChecker(GetSyncService(1)).Wait());
   ASSERT_TRUE(AwaitQuiescence());
   EXPECT_TRUE(AllModelsMatch());
   ASSERT_EQ(0, GetClient(1)->GetLastCycleSnapshot().num_encryption_conflicts());
 
   // Ensure everything is syncing normally by appending a final bookmark.
   ASSERT_TRUE(AddURL(1, 5, IndexedURLTitle(5), GURL(IndexedURL(5))) != NULL);
   ASSERT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
   EXPECT_TRUE(AllModelsMatch());
   ASSERT_EQ(0, GetClient(1)->GetLastCycleSnapshot().num_encryption_conflicts());
 }
@@ skipping 204 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, E2E_ONLY(SanitySetup)) {
   ASSERT_TRUE(SetupSync()) <<  "SetupSync() failed.";
 }
 
 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
                        E2E_ONLY(OneClientAddsBookmark)) {
   ASSERT_TRUE(SetupSync()) <<  "SetupSync() failed.";
   // All profiles should sync same bookmarks.
-  ASSERT_TRUE(AwaitAllModelsMatch()) <<
-      "Initial bookmark models did not match for all profiles";
+  ASSERT_TRUE(BookmarksMatchChecker().Wait())
+      << "Initial bookmark models did not match for all profiles";
   // For clean profiles, the bookmarks count should be zero. We are not
   // enforcing this, we only check that the final count is equal to initial
   // count plus new bookmarks count.
   int init_bookmarks_count = CountAllBookmarks(0);
 
   // Add one new bookmark to the first profile.
   ASSERT_TRUE(
       AddURL(0, "Google URL 0", GURL("http://www.google.com/0")) != NULL);
 
   // Blocks and waits for bookmarks models in all profiles to match.
-  ASSERT_TRUE(AwaitAllModelsMatch());
+  ASSERT_TRUE(BookmarksMatchChecker().Wait());
   // Check that total number of bookmarks is as expected.
   for (int i = 0; i < num_clients(); ++i) {
     ASSERT_EQ(CountAllBookmarks(i), init_bookmarks_count + 1) <<
         "Total bookmark count is wrong.";
   }
 }
 
 // TODO(shadi): crbug.com/569213: Enable this as E2E test.
 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
                        OneClientAddsFolderAndBookmark) {
   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
   // All profiles should sync same bookmarks.
-  ASSERT_TRUE(AwaitAllModelsMatch())
+  ASSERT_TRUE(BookmarksMatchChecker().Wait())
       << "Initial bookmark models did not match for all profiles";
 
   // Add one new bookmark to the first profile.
   const BookmarkNode* new_folder = AddFolder(0, 0, "Folder 0");
   ASSERT_TRUE(new_folder != NULL);
   ASSERT_TRUE(AddURL(0, new_folder, 0, "Google URL 0",
                      GURL("http://www.google.com/0")) != NULL);
 
   // Blocks and waits for bookmarks models in all profiles to match.
-  ASSERT_TRUE(AwaitAllModelsMatch());
+  ASSERT_TRUE(BookmarksMatchChecker().Wait());
   // Check that both profiles have the folder and the bookmark created above.
   for (int i = 0; i < num_clients(); ++i) {
     ASSERT_EQ(1, CountFoldersWithTitlesMatching(i, "Folder 0"))
         << "Failed to match the folder";
     ASSERT_EQ(
         1, CountBookmarksWithUrlsMatching(i, GURL("http://www.google.com/0")))
         << "Failed to match the bookmark";
   }
 }
 
 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
                        E2E_ONLY(TwoClientsAddBookmarks)) {
   ASSERT_TRUE(SetupSync()) <<  "SetupSync() failed.";
   // ALl profiles should sync same bookmarks.
-  ASSERT_TRUE(AwaitAllModelsMatch()) <<
-      "Initial bookmark models did not match for all profiles";
+  ASSERT_TRUE(BookmarksMatchChecker().Wait())
+      << "Initial bookmark models did not match for all profiles";
   // For clean profiles, the bookmarks count should be zero. We are not
   // enforcing this, we only check that the final count is equal to initial
   // count plus new bookmarks count.
   int init_bookmarks_count = CountAllBookmarks(0);
 
   // Add one new bookmark per profile.
   for (int i = 0; i < num_clients(); ++i) {
     ASSERT_TRUE(AddURL(i, base::StringPrintf("Google URL %d", i),
         GURL(base::StringPrintf("http://www.google.com/%d", i))) != NULL);
   }
 
   // Blocks and waits for bookmarks models in all profiles to match.
-  ASSERT_TRUE(AwaitAllModelsMatch());
+  ASSERT_TRUE(BookmarksMatchChecker().Wait());
 
   // Check that total number of bookmarks is as expected.
   for (int i = 0; i < num_clients(); ++i) {
     ASSERT_EQ(CountAllBookmarks(i), init_bookmarks_count + num_clients()) <<
         "Total bookmark count is wrong.";
   }
 }
 
 // Verify that a bookmark added on a client with bookmark syncing disabled gets
 // synced to a second client once bookmark syncing is re-enabled.
 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
                        E2E_ENABLED(AddBookmarkWhileDisabled)) {
   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
-  ASSERT_TRUE(AwaitAllModelsMatch())
+  ASSERT_TRUE(BookmarksMatchChecker().Wait())
       << "Initial bookmark models did not match for all profiles";
   const int initial_count = CountAllBookmarks(0);
 
   // Verify that we can sync. Add a bookmark on the first client and verify it's
   // synced to the second client.
   const std::string url_title = "a happy little url";
   const GURL url("https://example.com");
   ASSERT_TRUE(AddURL(0, GetBookmarkBarNode(0), 0, url_title, url) != NULL);
-  ASSERT_TRUE(AwaitAllModelsMatch());
+  ASSERT_TRUE(BookmarksMatchChecker().Wait());
   ASSERT_EQ(initial_count + 1, CountAllBookmarks(0));
   ASSERT_EQ(initial_count + 1, CountAllBookmarks(1));
 
   // Disable bookmark syncing on the first client, add another bookmark,
   // re-enable bookmark syncing and see that the second bookmark reaches the
   // second client.
   ASSERT_TRUE(GetClient(0)->DisableSyncForDatatype(syncer::BOOKMARKS));
   const std::string url_title_2 = "another happy little url";
   const GURL url_2("https://example.com/second");
   ASSERT_TRUE(AddURL(0, GetBookmarkBarNode(0), 0, url_title_2, url_2) != NULL);
   ASSERT_TRUE(GetClient(0)->EnableSyncForDatatype(syncer::BOOKMARKS));
-  ASSERT_TRUE(AwaitAllModelsMatch());
+  ASSERT_TRUE(BookmarksMatchChecker().Wait());
   ASSERT_EQ(initial_count + 2, CountAllBookmarks(0));
   ASSERT_EQ(initial_count + 2, CountAllBookmarks(1));
 }