sync: Refactor bookmarks integration tests

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 "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
@@ skipping 57 matching lines @@
       : model_(model),
         node_(node),
         wait_for_load_(false) {
     model->AddObserver(this);
   }
   virtual ~FaviconChangeObserver() {
     model_->RemoveObserver(this);
   }
   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 {}
   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,
@@ skipping 14 matching lines @@
       model->GetFavicon(node);
   }
   virtual void BookmarkNodeChildrenReordered(
       BookmarkModel* model,
       const BookmarkNode* node) OVERRIDE {}
   virtual void BookmarkNodeFaviconChanged(
       BookmarkModel* model,
       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();
     }
   }
 
  private:
   BookmarkModel* model_;
   const BookmarkNode* node_;
   bool wait_for_load_;
+  base::RunLoop run_loop_;
   DISALLOW_COPY_AND_ASSIGN(FaviconChangeObserver);
 };
 
 // A collection of URLs for which we have added favicons. Since loading a
 // favicon is an asynchronous operation and doesn't necessarily invoke a
 // callback, this collection is used to determine if we must wait for a URL's
 // favicon to load or not.
 std::set<GURL>* urls_with_favicons_ = NULL;
 
 // Returns the number of nodes of node type |node_type| in |model| whose
@@ skipping 170 matching lines @@
       1.0f).sk_bitmap();
   return FaviconRawBitmapsMatch(bitmap_a, bitmap_b);
 }
 
 // Does a deep comparison of BookmarkNode fields in |model_a| and |model_b|.
 // Returns true if they are all equal.
 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;
 }
 
 // Checks if the hierarchies in |model_a| and |model_b| are equivalent in
 // terms of the data model and favicon. Returns true if they both match.
 // Note: Some peripheral fields like creation times are allowed to mismatch.
 bool BookmarkModelsMatch(BookmarkModel* model_a, BookmarkModel* model_b) {
   bool ret_val = true;
   ui::TreeNodeIterator<const BookmarkNode> iterator_a(model_a->root_node());
   ui::TreeNodeIterator<const BookmarkNode> iterator_b(model_b->root_node());
   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();
     ret_val = ret_val && NodesMatch(node_a, node_b);
     if (node_a->is_folder() || node_b->is_folder())
       continue;
     ret_val = ret_val && FaviconsMatch(model_a, model_b, node_a, node_b);
   }
   ret_val = ret_val && (!iterator_b.has_next());
   return ret_val;
@@ skipping 290 matching lines @@
 }
 
 bool AllModelsMatchVerifier() {
   // Ensure that all tasks have finished processing on the history thread
   // and that any notifications the history thread may have sent have been
   // processed before comparing models.
   WaitForHistoryToProcessPendingTasks();
 
   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;
     }
   }
   return true;
 }
 
 bool ModelsMatch(int profile_a, int profile_b) {
   return BookmarkModelsMatch(GetBookmarkModel(profile_a),
                              GetBookmarkModel(profile_b));
 }
 
 bool AllModelsMatch() {
   // Ensure that all tasks have finished processing on the history thread
   // and that any notifications the history thread may have sent have been
   // processed before comparing models.
   WaitForHistoryToProcessPendingTasks();
 
   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());
   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_TRUE(nodes.size() >= 1);
@@ skipping 82 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);
 }
 
+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