sync: Refactor bookmarks integration tests

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

Index: chrome/browser/sync/test/integration/bookmarks_helper.cc
diff --git a/chrome/browser/sync/test/integration/bookmarks_helper.cc b/chrome/browser/sync/test/integration/bookmarks_helper.cc
index 2cfb377a2fec72db46e286d3fd4f59ca084ea096..fc07d2a1fae99974631db60f40cd11da66620a2a 100644
--- a/chrome/browser/sync/test/integration/bookmarks_helper.cc
+++ b/chrome/browser/sync/test/integration/bookmarks_helper.cc
@@ -75,13 +75,13 @@ class FaviconChangeObserver : public BookmarkModelObserver {
   }
   void WaitForGetFavicon() {
     wait_for_load_ = true;
-    content::RunMessageLoop();
+    run_loop_.Run();
     ASSERT_TRUE(node_->is_favicon_loaded());
     ASSERT_FALSE(model_->GetFavicon(node_).IsEmpty());
   }
   void WaitForSetFavicon() {
     wait_for_load_ = false;
-    content::RunMessageLoop();
+    run_loop_.Run();
   }
   virtual void BookmarkModelLoaded(BookmarkModel* model,
                                    bool ids_reassigned) OVERRIDE {}
@@ -116,7 +116,7 @@ class FaviconChangeObserver : public BookmarkModelObserver {
       const BookmarkNode* node) OVERRIDE {
     if (model == model_ && node == node_) {
       if (!wait_for_load_ || (wait_for_load_ && node->is_favicon_loaded()))
-        base::MessageLoopForUI::current()->Quit();
+        run_loop_.Quit();
     }
   }
 
@@ -124,6 +124,7 @@ class FaviconChangeObserver : public BookmarkModelObserver {
   BookmarkModel* model_;
   const BookmarkNode* node_;
   bool wait_for_load_;
+  base::RunLoop run_loop_;
   DISALLOW_COPY_AND_ASSIGN(FaviconChangeObserver);
 };
 
@@ -314,24 +315,22 @@ bool NodesMatch(const BookmarkNode* node_a, const BookmarkNode* node_b) {
   if (node_a == NULL || node_b == NULL)
     return node_a == node_b;
   if (node_a->is_folder() != node_b->is_folder()) {
-    LOG(ERROR) << "Cannot compare folder with bookmark";
+    VLOG(1) << "Cannot compare folder with bookmark";
     return false;
   }
   if (node_a->GetTitle() != node_b->GetTitle()) {
-    LOG(ERROR) << "Title mismatch: " << node_a->GetTitle() << " vs. "
-               << node_b->GetTitle();
+    VLOG(1) << "Title mismatch: " << node_a->GetTitle() << " vs. "
+            << node_b->GetTitle();
     return false;
   }
   if (node_a->url() != node_b->url()) {
-    LOG(ERROR) << "URL mismatch: " << node_a->url() << " vs. "
-               << node_b->url();
+    VLOG(1) << "URL mismatch: " << node_a->url() << " vs. " << node_b->url();
     return false;
   }
   if (node_a->parent()->GetIndexOf(node_a) !=
       node_b->parent()->GetIndexOf(node_b)) {
-    LOG(ERROR) << "Index mismatch: "
-               << node_a->parent()->GetIndexOf(node_a) << " vs. "
-               << node_b->parent()->GetIndexOf(node_b);
+    VLOG(1) << "Index mismatch: " << node_a->parent()->GetIndexOf(node_a)
+            << " vs. " << node_b->parent()->GetIndexOf(node_b);
     return false;
   }
   return true;
@@ -347,7 +346,7 @@ bool BookmarkModelsMatch(BookmarkModel* model_a, BookmarkModel* model_b) {
   while (iterator_a.has_next()) {
     const BookmarkNode* node_a = iterator_a.Next();
     if (!iterator_b.has_next()) {
-      LOG(ERROR) << "Models do not match.";
+      VLOG(1) << "Models do not match.";
       return false;
     }
     const BookmarkNode* node_b = iterator_b.Next();
@@ -658,7 +657,7 @@ bool AllModelsMatchVerifier() {
 
   for (int i = 0; i < sync_datatype_helper::test()->num_clients(); ++i) {
     if (!ModelMatchesVerifier(i)) {
-      LOG(ERROR) << "Model " << i << " does not match the verifier.";
+      VLOG(1) << "Model " << i << " does not match the verifier.";
       return false;
     }
   }
@@ -678,48 +677,13 @@ bool AllModelsMatch() {
 
   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.";
+      VLOG(1) << "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();
-  virtual ~AllModelsMatchChecker();
-
-  virtual bool IsExitConditionSatisfied() OVERRIDE;
-  virtual 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();
-}
-
-
 bool ContainsDuplicateBookmarks(int profile) {
   ui::TreeNodeIterator<const BookmarkNode> iterator(
       GetBookmarkModel(profile)->root_node());
@@ -822,4 +786,155 @@ std::string IndexedSubsubfolderName(int i) {
   return base::StringPrintf("Subsubfolder Name %d", i);
 }
 
+class BookmarkConditionChecker : public StatusChangeChecker,
+                                 public BookmarkModelObserver {
+ public:
+  BookmarkConditionChecker(base::Callback<bool()> exit_condition,
+                           const std::string& debug_message);
+  virtual ~BookmarkConditionChecker();
+
+  // Implementation of StatusChangeChecker.
+  virtual std::string GetDebugMessage() const OVERRIDE;
+  virtual bool IsExitConditionSatisfied() OVERRIDE;
+
+  // Implementation of BookmarkModelObserver.
+  virtual void BookmarkModelLoaded(BookmarkModel* model,
+                                   bool ids_reassigned) OVERRIDE;
+  virtual void BookmarkNodeMoved(BookmarkModel* model,
+                                 const BookmarkNode* old_parent,
+                                 int old_index,
+                                 const BookmarkNode* new_parent,
+                                 int new_index) OVERRIDE;
+  virtual void BookmarkNodeAdded(BookmarkModel* model,
+                                 const BookmarkNode* parent,
+                                 int index) OVERRIDE;
+  virtual void BookmarkNodeRemoved(BookmarkModel* model,
+                                   const BookmarkNode* parent,
+                                   int old_index,
+                                   const BookmarkNode* node,
+                                   const std::set<GURL>& removed_urls) OVERRIDE;
+  virtual void BookmarkNodeChanged(BookmarkModel* model,
+                                   const BookmarkNode* node) OVERRIDE;
+  virtual void BookmarkNodeFaviconChanged(BookmarkModel* model,
+                                          const BookmarkNode* node) OVERRIDE;
+  virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
+                                             const BookmarkNode* node) OVERRIDE;
+  virtual void BookmarkAllUserNodesRemoved(
+      BookmarkModel* model,
+      const std::set<GURL>& removed_urls) OVERRIDE;
+
+  // Waits until the condition to be met or a timeout occurs.
+  void Wait();
+
+ private:
+  base::Callback<bool()> exit_condition_;
+  std::string debug_message_;
+  bool registered_;
+};
+
+BookmarkConditionChecker::BookmarkConditionChecker(
+    base::Callback<bool()> exit_condition,
+    const std::string& debug_message)
+    : exit_condition_(exit_condition),
+      debug_message_(debug_message),
+      registered_(false) {
+}
+
+BookmarkConditionChecker::~BookmarkConditionChecker() {
+  if (!registered_)
+    return;
+
+  for (int i = 0; i < sync_datatype_helper::test()->num_clients(); ++i) {
+    GetBookmarkModel(i)->RemoveObserver(this);
+  }
+}
+
+std::string BookmarkConditionChecker::GetDebugMessage() const {
+  return debug_message_;
+}
+
+bool BookmarkConditionChecker::IsExitConditionSatisfied() {
+  return exit_condition_.Run();
+}
+
+// Implementation of BookmarkModelObserver.
+void BookmarkConditionChecker::BookmarkModelLoaded(BookmarkModel* model,
+                                                   bool ids_reassigned) {
+  CheckExitCondition();
+}
+
+void BookmarkConditionChecker::BookmarkNodeMoved(BookmarkModel* model,
+                                                 const BookmarkNode* old_parent,
+                                                 int old_index,
+                                                 const BookmarkNode* new_parent,
+                                                 int new_index) {
+  CheckExitCondition();
+}
+
+void BookmarkConditionChecker::BookmarkNodeAdded(BookmarkModel* model,
+                                                 const BookmarkNode* parent,
+                                                 int index) {
+  CheckExitCondition();
+}
+
+void BookmarkConditionChecker::BookmarkNodeRemoved(
+    BookmarkModel* model,
+    const BookmarkNode* parent,
+    int old_index,
+    const BookmarkNode* node,
+    const std::set<GURL>& removed_urls) {
+  CheckExitCondition();
+}
+
+void BookmarkConditionChecker::BookmarkNodeChanged(BookmarkModel* model,
+                                                   const BookmarkNode* node) {
+  CheckExitCondition();
+}
+
+void BookmarkConditionChecker::BookmarkNodeFaviconChanged(
+    BookmarkModel* model,
+    const BookmarkNode* node) {
+  CheckExitCondition();
+}
+
+void BookmarkConditionChecker::BookmarkNodeChildrenReordered(
+    BookmarkModel* model,
+    const BookmarkNode* node) {
+  CheckExitCondition();
+}
+
+void BookmarkConditionChecker::BookmarkAllUserNodesRemoved(
+    BookmarkModel* model,
+    const std::set<GURL>& removed_urls) {
+  CheckExitCondition();
+}
+
+void BookmarkConditionChecker::Wait() {
+  for (int i = 0; i < sync_datatype_helper::test()->num_clients(); ++i) {
+    GetBookmarkModel(i)->AddObserver(this);
+  }
+  registered_ = true;
+
+  if (IsExitConditionSatisfied()) {
+    VLOG(1) << "Finished without wait: " << GetDebugMessage();
+    return;
+  }
+
+  StartBlockingWait();
+}
+
+bool AwaitAllModelsMatch() {
+  BookmarkConditionChecker checker(base::Bind(&AllModelsMatch),
+                                   "Waiting for models to match");
+  checker.Wait();
+  return !checker.TimedOut();
+}
+
+bool AwaitAllModelsMatchVerifier() {
+  BookmarkConditionChecker checker(base::Bind(&AllModelsMatchVerifier),
+                                   "Waiting for models to match verifier");
+  checker.Wait();
+  return !checker.TimedOut();
+}
+
 }  // namespace bookmarks_helper