Debugging updates for sync integration tests

chrome/test/live_sync/bookmark_model_verifier.cc

 // Copyright (c) 2010 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/test/live_sync/bookmark_model_verifier.h"
 
 #include <vector>
 #include <stack>
 
 #include "base/rand_util.h"
@@ skipping 53 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(FaviconLoadObserver);
 };
 
 }
 
 // static
 bool BookmarkModelVerifier::NodesMatch(const BookmarkNode* node_a,
                                        const BookmarkNode* node_b) {
   if (node_a == NULL || node_b == NULL)
     return node_a == node_b;
-  bool ret_val = true;
-  ret_val = ret_val && (node_a->GetTitle() == node_b->GetTitle());
-  ret_val = ret_val && (node_a->is_folder() == node_b->is_folder());
-  ret_val = ret_val && (node_a->GetURL() == node_b->GetURL());
-  ret_val = ret_val && (node_a->GetParent()->IndexOfChild(node_a) ==
-                        node_b->GetParent()->IndexOfChild(node_b));
-  return ret_val;
+  if (node_a->is_folder() != node_b->is_folder()) {
+    LOG(ERROR) << "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();
+    return false;
+  }
+  if (node_a->GetURL() != node_b->GetURL()) {
+    LOG(ERROR) << "URL mismatch: " << node_a->GetURL() << " vs. "
+               << node_b->GetURL();
+    return false;
+  }
+  if (node_a->GetParent()->IndexOfChild(node_a) !=
+      node_b->GetParent()->IndexOfChild(node_b)) {
+    LOG(ERROR) << "Index mismatch: "
+               << node_a->GetParent()->IndexOfChild(node_a) << " vs. "
+               << node_b->GetParent()->IndexOfChild(node_b);
+    return false;
+  }
+  return true;
 }
 
 // static
 bool BookmarkModelVerifier::ModelsMatch(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();
     EXPECT_TRUE(iterator_b.has_next());
     const BookmarkNode* node_b = iterator_b.Next();
     ret_val = ret_val && NodesMatch(node_a, node_b);
     const SkBitmap& bitmap_a = model_a->GetFavIcon(node_a);
     const SkBitmap& bitmap_b = model_b->GetFavIcon(node_b);
     ret_val = ret_val && FaviconsMatch(bitmap_a, bitmap_b);
   }
   ret_val = ret_val && (!iterator_b.has_next());
   return ret_val;
 }
 
 bool BookmarkModelVerifier::FaviconsMatch(const SkBitmap& bitmap_a,
                                           const SkBitmap& bitmap_b) {
   if (bitmap_a.getSize() == 0U && bitmap_a.getSize() == 0U)
     return true;
   if ((bitmap_a.getSize() != bitmap_b.getSize()) ||
       (bitmap_a.width() != bitmap_b.width()) ||
-      (bitmap_a.height() != bitmap_b.height()))
+      (bitmap_a.height() != bitmap_b.height())) {
+    LOG(ERROR) << "Favicon size mismatch: " << bitmap_a.getSize() << " ("
+               << bitmap_a.width() << "x" << bitmap_a.height() << ") vs. "
+               << bitmap_b.getSize() << " (" << bitmap_b.width() << "x"
+               << bitmap_b.height() << ")";
     return false;
+  }
   SkAutoLockPixels bitmap_lock_a(bitmap_a);
   SkAutoLockPixels bitmap_lock_b(bitmap_b);
   void* node_pixel_addr_a = bitmap_a.getPixels();
   EXPECT_TRUE(node_pixel_addr_a);
   void* node_pixel_addr_b = bitmap_b.getPixels();
   EXPECT_TRUE(node_pixel_addr_b);
-  return (memcmp(node_pixel_addr_a,
-                 node_pixel_addr_b,
-                 bitmap_a.getSize()) ==  0);
+  if (memcmp(node_pixel_addr_a, node_pixel_addr_b, bitmap_a.getSize()) !=  0) {
+    LOG(ERROR) << "Favicon bitmap mismatch";
+    return false;
+  } else {
+    return true;
+  }
 }
 
 bool BookmarkModelVerifier::ContainsDuplicateBookmarks(BookmarkModel* model) {
   ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node());
   while (iterator.has_next()) {
     const BookmarkNode* node = iterator.Next();
     if (node->type() != BookmarkNode::URL)
       continue;
     std::vector<const BookmarkNode*> nodes;
     model->GetNodesByURL(node->GetURL(), &nodes);
@@ skipping 177 matching lines @@
     const BookmarkNode* v_node = NULL;
     FindNodeInVerifier(model, node, &v_node);
     bookmark_utils::ApplyEditsWithNoGroupChange(
         verifier_model_, v_node->GetParent(),
         BookmarkEditor::EditDetails(v_node), v_node->GetTitle(), new_url);
   }
   return bookmark_utils::ApplyEditsWithNoGroupChange(
       model, node->GetParent(), BookmarkEditor::EditDetails(node),
       node->GetTitle(), new_url);
 }