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

chrome/browser/sync/test/integration/bookmarks_helper.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 "chrome/browser/sync/test/integration/bookmarks_helper.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
@@ skipping 11 matching lines @@
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/managed_bookmark_service_factory.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
-#include "chrome/browser/sync/test/integration/await_match_status_change_checker.h"
-#include "chrome/browser/sync/test/integration/multi_client_status_change_checker.h"
 #include "chrome/browser/sync/test/integration/profile_sync_service_harness.h"
-#include "chrome/browser/sync/test/integration/single_client_status_change_checker.h"
 #include "chrome/browser/sync/test/integration/sync_datatype_helper.h"
 #include "chrome/browser/sync/test/integration/sync_test.h"
 #include "chrome/common/chrome_paths.h"
 #include "components/bookmarks/browser/bookmark_client.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/bookmark_model_observer.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
 #include "components/bookmarks/managed/managed_bookmark_service.h"
 #include "components/browser_sync/profile_sync_service.h"
 #include "components/favicon/core/favicon_service.h"
@@ skipping 22 matching lines @@
   bool RunOnDBThread(history::HistoryBackend* backend,
                      history::HistoryDatabase* db) override {
     content::RunAllPendingInMessageLoop();
     done_->Signal();
     return true;
   }
 
   void DoneRunOnMainThread() override {}
 
  private:
-  ~HistoryEmptyTask() override {}
-
   base::WaitableEvent* done_;
 };
 
 // Helper class used to wait for changes to take effect on the favicon of a
 // particular bookmark node in a particular bookmark model.
 class FaviconChangeObserver : public bookmarks::BookmarkModelObserver {
  public:
   FaviconChangeObserver(BookmarkModel* model, const BookmarkNode* node)
       : model_(model),
         node_(node),
@@ skipping 124 matching lines @@
 struct FaviconData {
   FaviconData() {
   }
 
   FaviconData(const gfx::Image& favicon_image,
               const GURL& favicon_url)
       : image(favicon_image),
         icon_url(favicon_url) {
   }
 
-  ~FaviconData() {
-  }
-
   gfx::Image image;
   GURL icon_url;
 };
 
 // Gets the favicon and icon URL associated with |node| in |model|.
 FaviconData GetFaviconData(BookmarkModel* model,
                            const BookmarkNode* node) {
   // If a favicon wasn't explicitly set for a particular URL, simply return its
   // blank favicon.
   if (!urls_with_favicons_ ||
@@ skipping 543 matching lines @@
 
   for (int i = 1; i < sync_datatype_helper::test()->num_clients(); ++i) {
     if (!ModelsMatch(0, i)) {
       LOG(ERROR) << "Model " << i << " does not match Model 0.";
       return false;
     }
   }
   return true;
 }
 
-namespace {
-
-// Helper class used in the implementation of AwaitAllModelsMatch.
-class AllModelsMatchChecker : public MultiClientStatusChangeChecker {
- public:
-  AllModelsMatchChecker();
-  ~AllModelsMatchChecker() override;
-
-  bool IsExitConditionSatisfied() override;
-  std::string GetDebugMessage() const override;
-};
-
-AllModelsMatchChecker::AllModelsMatchChecker()
-    : MultiClientStatusChangeChecker(
-        sync_datatype_helper::test()->GetSyncServices()) {}
-
-AllModelsMatchChecker::~AllModelsMatchChecker() {}
-
-bool AllModelsMatchChecker::IsExitConditionSatisfied() {
-  return AllModelsMatch();
-}
-
-std::string AllModelsMatchChecker::GetDebugMessage() const {
-  return "Waiting for matching models";
-}
-
-}  //  namespace
-
-bool AwaitAllModelsMatch() {
-  AllModelsMatchChecker checker;
-  checker.Wait();
-  return !checker.TimedOut();
-}
-
-namespace {
-
-// TODO(pvalenzuela): Remove this class and instead use
-// AwaitMatchStatusChangeChecker.
-class CountBookmarksWithTitlesMatchingChecker
-    : public SingleClientStatusChangeChecker {
- public:
-  CountBookmarksWithTitlesMatchingChecker(
-      browser_sync::ProfileSyncService* service,
-      int profile_index,
-      const std::string& title,
-      int expected_count)
-      : SingleClientStatusChangeChecker(service),
-        profile_index_(profile_index),
-        title_(title),
-        expected_count_(expected_count) {
-    DCHECK_GE(expected_count, 0) << "expected_count must be non-negative.";
-  }
-
-  bool IsExitConditionSatisfied() override {
-    int actual_count = CountBookmarksWithTitlesMatching(profile_index_, title_);
-    return expected_count_ == actual_count;
-  }
-
-  std::string GetDebugMessage() const override {
-    return "Waiting for bookmark count to match";
-  }
-
- private:
-  const int profile_index_;
-  const std::string title_;
-  const int expected_count_;
-};
-
-}  // namespace
-
-bool AwaitCountBookmarksWithTitlesMatching(int profile,
-                                           const std::string& title,
-                                           int expected_count) {
-  browser_sync::ProfileSyncService* service =
-      sync_datatype_helper::test()->GetSyncService(profile);
-  CountBookmarksWithTitlesMatchingChecker checker(service,
-                                                  profile,
-                                                  title,
-                                                  expected_count);
-  checker.Wait();
-  return !checker.TimedOut();
-}
-
-
-bool BookmarkCountsByUrlMatch(int profile,
-                              const GURL& url,
-                              int expected_count) {
-  int actual_count = CountBookmarksWithUrlsMatching(profile, url);
-  if (expected_count != actual_count) {
-    DVLOG(1) << base::StringPrintf("Expected %d URL(s), but there were %d.",
-                                   expected_count,
-                                   actual_count);
-    return false;
-  }
-  return true;
-}
-
-bool AwaitCountBookmarksWithUrlsMatching(int profile,
-                                         const GURL& url,
-                                         int expected_count) {
-  AwaitMatchStatusChangeChecker checker(base::Bind(BookmarkCountsByUrlMatch,
-                                                   profile,
-                                                   base::ConstRef(url),
-                                                   expected_count),
-                                        "Bookmark URL counts match.");
-  checker.Wait();
-  return !checker.TimedOut();
-}
-
 bool ContainsDuplicateBookmarks(int profile) {
   ui::TreeNodeIterator<const BookmarkNode> iterator(
       GetBookmarkModel(profile)->root_node());
   while (iterator.has_next()) {
     const BookmarkNode* node = iterator.Next();
     if (node->is_folder())
       continue;
     std::vector<const BookmarkNode*> nodes;
     GetBookmarkModel(profile)->GetNodesByURL(node->url(), &nodes);
     EXPECT_GE(nodes.size(), 1U);
@@ skipping 94 matching lines @@
 
 std::string IndexedSubfolderName(int i) {
   return base::StringPrintf("Subfolder Name %d", i);
 }
 
 std::string IndexedSubsubfolderName(int i) {
   return base::StringPrintf("Subsubfolder Name %d", i);
 }
 
 }  // namespace bookmarks_helper
+
+BookmarksMatchChecker::BookmarksMatchChecker()
+    : MultiClientStatusChangeChecker(
+          sync_datatype_helper::test()->GetSyncServices()) {}
+
+bool BookmarksMatchChecker::IsExitConditionSatisfied() {
+  return bookmarks_helper::AllModelsMatch();
+}
+
+std::string BookmarksMatchChecker::GetDebugMessage() const {
+  return "Waiting for matching models";
+}
+
+BookmarksTitleChecker::BookmarksTitleChecker(int profile_index,
+                                             const std::string& title,
+                                             int expected_count)
+    : SingleClientStatusChangeChecker(
+          sync_datatype_helper::test()->GetSyncService(profile_index)),
+      profile_index_(profile_index),
+      title_(title),
+      expected_count_(expected_count) {
+  DCHECK_GE(expected_count, 0) << "expected_count must be non-negative.";
+}
+
+bool BookmarksTitleChecker::IsExitConditionSatisfied() {
+  int actual_count = bookmarks_helper::CountBookmarksWithTitlesMatching(
+      profile_index_, title_);
+  return expected_count_ == actual_count;
+}
+
+std::string BookmarksTitleChecker::GetDebugMessage() const {
+  return "Waiting for bookmark count to match";
+}
+
+namespace {
+
+bool BookmarkCountsByUrlMatch(int profile,
+                              const GURL& url,
+                              int expected_count) {
+  int actual_count =
+      bookmarks_helper::CountBookmarksWithUrlsMatching(profile, url);
+  if (expected_count != actual_count) {
+    DVLOG(1) << base::StringPrintf("Expected %d URL(s), but there were %d.",
+                                   expected_count, actual_count);
+    return false;
+  }
+  return true;
+}
+
+}  // namespace
+
+BookmarksUrlChecker::BookmarksUrlChecker(int profile,
+                                         const GURL& url,
+                                         int expected_count)
+    : AwaitMatchStatusChangeChecker(base::Bind(BookmarkCountsByUrlMatch,
+                                               profile,
+                                               base::ConstRef(url),
+                                               expected_count),
+                                    "Bookmark URL counts match.") {}