| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome/test/live_sync/bookmark_model_verifier.h" | |
| 6 | |
| 7 #include <stack> | |
| 8 #include <vector> | |
| 9 | |
| 10 #include "base/rand_util.h" | |
| 11 #include "base/string_number_conversions.h" | |
| 12 #include "chrome/browser/bookmarks/bookmark_model.h" | |
| 13 #include "chrome/browser/bookmarks/bookmark_model_observer.h" | |
| 14 #include "chrome/browser/bookmarks/bookmark_utils.h" | |
| 15 #include "chrome/browser/sync/glue/bookmark_change_processor.h" | |
| 16 #include "chrome/test/ui_test_utils.h" | |
| 17 #include "testing/gtest/include/gtest/gtest.h" | |
| 18 #include "ui/base/models/tree_node_iterator.h" | |
| 19 | |
| 20 namespace { | |
| 21 | |
| 22 // Helper class used to wait for changes to take effect on the favicon of a | |
| 23 // particular bookmark node in a particular bookmark model. | |
| 24 class FaviconChangeObserver : public BookmarkModelObserver { | |
| 25 public: | |
| 26 FaviconChangeObserver(BookmarkModel* model, const BookmarkNode* node) | |
| 27 : model_(model), | |
| 28 node_(node), | |
| 29 wait_for_load_(false) { | |
| 30 model->AddObserver(this); | |
| 31 } | |
| 32 virtual ~FaviconChangeObserver() { | |
| 33 model_->RemoveObserver(this); | |
| 34 } | |
| 35 void WaitForGetFavicon() { | |
| 36 wait_for_load_ = true; | |
| 37 ui_test_utils::RunMessageLoop(); | |
| 38 ASSERT_TRUE(node_->is_favicon_loaded()); | |
| 39 } | |
| 40 void WaitForSetFavicon() { | |
| 41 wait_for_load_ = false; | |
| 42 ui_test_utils::RunMessageLoop(); | |
| 43 } | |
| 44 virtual void Loaded(BookmarkModel* model) OVERRIDE {} | |
| 45 virtual void BookmarkNodeMoved(BookmarkModel* model, | |
| 46 const BookmarkNode* old_parent, | |
| 47 int old_index, | |
| 48 const BookmarkNode* new_parent, | |
| 49 int new_index) OVERRIDE {} | |
| 50 virtual void BookmarkNodeAdded(BookmarkModel* model, | |
| 51 const BookmarkNode* parent, | |
| 52 int index) OVERRIDE {} | |
| 53 virtual void BookmarkNodeRemoved(BookmarkModel* model, | |
| 54 const BookmarkNode* parent, | |
| 55 int old_index, | |
| 56 const BookmarkNode* node) OVERRIDE {} | |
| 57 virtual void BookmarkNodeChanged(BookmarkModel* model, | |
| 58 const BookmarkNode* node) OVERRIDE { | |
| 59 if (model == model_ && node == node_) | |
| 60 model->GetFavicon(node); | |
| 61 } | |
| 62 virtual void BookmarkNodeChildrenReordered( | |
| 63 BookmarkModel* model, | |
| 64 const BookmarkNode* node) OVERRIDE {} | |
| 65 virtual void BookmarkNodeFaviconChanged( | |
| 66 BookmarkModel* model, | |
| 67 const BookmarkNode* node) OVERRIDE { | |
| 68 if (model == model_ && node == node_) { | |
| 69 if (!wait_for_load_ || (wait_for_load_ && node->is_favicon_loaded())) | |
| 70 MessageLoopForUI::current()->Quit(); | |
| 71 } | |
| 72 } | |
| 73 | |
| 74 private: | |
| 75 BookmarkModel* model_; | |
| 76 const BookmarkNode* node_; | |
| 77 bool wait_for_load_; | |
| 78 DISALLOW_COPY_AND_ASSIGN(FaviconChangeObserver); | |
| 79 }; | |
| 80 | |
| 81 } // namespace | |
| 82 | |
| 83 BookmarkModelVerifier::BookmarkModelVerifier(BookmarkModel* model) | |
| 84 : verifier_model_(model), | |
| 85 use_verifier_model_(true) {} | |
| 86 | |
| 87 BookmarkModelVerifier::~BookmarkModelVerifier() {} | |
| 88 | |
| 89 bool BookmarkModelVerifier::NodesMatch(const BookmarkNode* node_a, | |
| 90 const BookmarkNode* node_b) const { | |
| 91 if (node_a == NULL || node_b == NULL) | |
| 92 return node_a == node_b; | |
| 93 if (node_a->is_folder() != node_b->is_folder()) { | |
| 94 LOG(ERROR) << "Cannot compare folder with bookmark"; | |
| 95 return false; | |
| 96 } | |
| 97 if (node_a->GetTitle() != node_b->GetTitle()) { | |
| 98 LOG(ERROR) << "Title mismatch: " << node_a->GetTitle() << " vs. " | |
| 99 << node_b->GetTitle(); | |
| 100 return false; | |
| 101 } | |
| 102 if (node_a->GetURL() != node_b->GetURL()) { | |
| 103 LOG(ERROR) << "URL mismatch: " << node_a->GetURL() << " vs. " | |
| 104 << node_b->GetURL(); | |
| 105 return false; | |
| 106 } | |
| 107 if (node_a->parent()->GetIndexOf(node_a) != | |
| 108 node_b->parent()->GetIndexOf(node_b)) { | |
| 109 LOG(ERROR) << "Index mismatch: " | |
| 110 << node_a->parent()->GetIndexOf(node_a) << " vs. " | |
| 111 << node_b->parent()->GetIndexOf(node_b); | |
| 112 return false; | |
| 113 } | |
| 114 return true; | |
| 115 } | |
| 116 | |
| 117 bool BookmarkModelVerifier::ModelsMatch(BookmarkModel* model_a, | |
| 118 BookmarkModel* model_b) const { | |
| 119 bool ret_val = true; | |
| 120 ui::TreeNodeIterator<const BookmarkNode> iterator_a(model_a->root_node()); | |
| 121 ui::TreeNodeIterator<const BookmarkNode> iterator_b(model_b->root_node()); | |
| 122 while (iterator_a.has_next()) { | |
| 123 const BookmarkNode* node_a = iterator_a.Next(); | |
| 124 if (!iterator_b.has_next()) { | |
| 125 LOG(ERROR) << "Models do not match."; | |
| 126 return false; | |
| 127 } | |
| 128 const BookmarkNode* node_b = iterator_b.Next(); | |
| 129 ret_val = ret_val && NodesMatch(node_a, node_b); | |
| 130 if (node_a->is_folder() || node_b->is_folder()) | |
| 131 continue; | |
| 132 ret_val = ret_val && FaviconsMatch(model_a, model_b, node_a, node_b); | |
| 133 } | |
| 134 ret_val = ret_val && (!iterator_b.has_next()); | |
| 135 return ret_val; | |
| 136 } | |
| 137 | |
| 138 bool BookmarkModelVerifier::FaviconsMatch(BookmarkModel* model_a, | |
| 139 BookmarkModel* model_b, | |
| 140 const BookmarkNode* node_a, | |
| 141 const BookmarkNode* node_b) const { | |
| 142 const SkBitmap& bitmap_a = GetFavicon(model_a, node_a); | |
| 143 const SkBitmap& bitmap_b = GetFavicon(model_b, node_b); | |
| 144 return FaviconBitmapsMatch(bitmap_a, bitmap_b); | |
| 145 } | |
| 146 | |
| 147 bool BookmarkModelVerifier::FaviconBitmapsMatch( | |
| 148 const SkBitmap& bitmap_a, | |
| 149 const SkBitmap& bitmap_b) const { | |
| 150 if (bitmap_a.getSize() == 0U && bitmap_a.getSize() == 0U) | |
| 151 return true; | |
| 152 if ((bitmap_a.getSize() != bitmap_b.getSize()) || | |
| 153 (bitmap_a.width() != bitmap_b.width()) || | |
| 154 (bitmap_a.height() != bitmap_b.height())) { | |
| 155 LOG(ERROR) << "Favicon size mismatch: " << bitmap_a.getSize() << " (" | |
| 156 << bitmap_a.width() << "x" << bitmap_a.height() << ") vs. " | |
| 157 << bitmap_b.getSize() << " (" << bitmap_b.width() << "x" | |
| 158 << bitmap_b.height() << ")"; | |
| 159 return false; | |
| 160 } | |
| 161 SkAutoLockPixels bitmap_lock_a(bitmap_a); | |
| 162 SkAutoLockPixels bitmap_lock_b(bitmap_b); | |
| 163 void* node_pixel_addr_a = bitmap_a.getPixels(); | |
| 164 EXPECT_TRUE(node_pixel_addr_a); | |
| 165 void* node_pixel_addr_b = bitmap_b.getPixels(); | |
| 166 EXPECT_TRUE(node_pixel_addr_b); | |
| 167 if (memcmp(node_pixel_addr_a, node_pixel_addr_b, bitmap_a.getSize()) != 0) { | |
| 168 LOG(ERROR) << "Favicon bitmap mismatch"; | |
| 169 return false; | |
| 170 } else { | |
| 171 return true; | |
| 172 } | |
| 173 } | |
| 174 | |
| 175 bool BookmarkModelVerifier::ContainsDuplicateBookmarks( | |
| 176 BookmarkModel* model) const { | |
| 177 ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node()); | |
| 178 while (iterator.has_next()) { | |
| 179 const BookmarkNode* node = iterator.Next(); | |
| 180 if (node->is_folder()) | |
| 181 continue; | |
| 182 std::vector<const BookmarkNode*> nodes; | |
| 183 model->GetNodesByURL(node->GetURL(), &nodes); | |
| 184 EXPECT_TRUE(nodes.size() >= 1); | |
| 185 for (std::vector<const BookmarkNode*>::const_iterator it = nodes.begin(); | |
| 186 it != nodes.end(); ++it) { | |
| 187 if (node->id() != (*it)->id() && | |
| 188 node->parent() == (*it)->parent() && | |
| 189 node->GetTitle() == (*it)->GetTitle()){ | |
| 190 return true; | |
| 191 } | |
| 192 } | |
| 193 } | |
| 194 return false; | |
| 195 } | |
| 196 | |
| 197 int BookmarkModelVerifier::CountNodesWithTitlesMatching( | |
| 198 BookmarkModel* model, | |
| 199 BookmarkNode::Type node_type, | |
| 200 const string16& title) const { | |
| 201 ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node()); | |
| 202 // Walk through the model tree looking for bookmark nodes of node type | |
| 203 // |node_type| whose titles match |title|. | |
| 204 int count = 0; | |
| 205 while (iterator.has_next()) { | |
| 206 const BookmarkNode* node = iterator.Next(); | |
| 207 if ((node->type() == node_type) && (node->GetTitle() == title)) | |
| 208 ++count; | |
| 209 } | |
| 210 return count; | |
| 211 } | |
| 212 | |
| 213 void BookmarkModelVerifier::FindNodeInVerifier(BookmarkModel* foreign_model, | |
| 214 const BookmarkNode* foreign_node, | |
| 215 const BookmarkNode** result) { | |
| 216 // Climb the tree. | |
| 217 std::stack<int> path; | |
| 218 const BookmarkNode* walker = foreign_node; | |
| 219 while (walker != foreign_model->root_node()) { | |
| 220 path.push(walker->parent()->GetIndexOf(walker)); | |
| 221 walker = walker->parent(); | |
| 222 } | |
| 223 | |
| 224 // Swing over to the other tree. | |
| 225 walker = verifier_model_->root_node(); | |
| 226 | |
| 227 // Climb down. | |
| 228 while (!path.empty()) { | |
| 229 ASSERT_TRUE(walker->is_folder()); | |
| 230 ASSERT_LT(path.top(), walker->child_count()); | |
| 231 walker = walker->GetChild(path.top()); | |
| 232 path.pop(); | |
| 233 } | |
| 234 | |
| 235 ASSERT_TRUE(NodesMatch(foreign_node, walker)); | |
| 236 *result = walker; | |
| 237 } | |
| 238 | |
| 239 const BookmarkNode* BookmarkModelVerifier::AddFolder(BookmarkModel* model, | |
| 240 const BookmarkNode* parent, | |
| 241 int index, | |
| 242 const string16& title) { | |
| 243 const BookmarkNode* result = model->AddFolder(parent, index, title); | |
| 244 EXPECT_TRUE(result); | |
| 245 if (!result) | |
| 246 return NULL; | |
| 247 if (use_verifier_model_) { | |
| 248 const BookmarkNode* v_parent = NULL; | |
| 249 FindNodeInVerifier(model, parent, &v_parent); | |
| 250 const BookmarkNode* v_node = verifier_model_->AddFolder( | |
| 251 v_parent, index, title); | |
| 252 EXPECT_TRUE(v_node); | |
| 253 if (!v_node) | |
| 254 return NULL; | |
| 255 EXPECT_TRUE(NodesMatch(v_node, result)); | |
| 256 } | |
| 257 return result; | |
| 258 } | |
| 259 | |
| 260 const BookmarkNode* BookmarkModelVerifier::AddURL(BookmarkModel* model, | |
| 261 const BookmarkNode* parent, | |
| 262 int index, | |
| 263 const string16& title, | |
| 264 const GURL& url) { | |
| 265 const BookmarkNode* result = model->AddURL(parent, index, title, url); | |
| 266 EXPECT_TRUE(result); | |
| 267 if (!result) | |
| 268 return NULL; | |
| 269 if (use_verifier_model_) { | |
| 270 const BookmarkNode* v_parent = NULL; | |
| 271 FindNodeInVerifier(model, parent, &v_parent); | |
| 272 const BookmarkNode* v_node = | |
| 273 verifier_model_->AddURL(v_parent, index, title, url); | |
| 274 EXPECT_TRUE(v_node); | |
| 275 if (!v_node) | |
| 276 return NULL; | |
| 277 EXPECT_TRUE(NodesMatch(v_node, result)); | |
| 278 } | |
| 279 return result; | |
| 280 } | |
| 281 | |
| 282 void BookmarkModelVerifier::SetTitle(BookmarkModel* model, | |
| 283 const BookmarkNode* node, | |
| 284 const string16& title) { | |
| 285 if (use_verifier_model_) { | |
| 286 const BookmarkNode* v_node = NULL; | |
| 287 FindNodeInVerifier(model, node, &v_node); | |
| 288 verifier_model_->SetTitle(v_node, title); | |
| 289 } | |
| 290 model->SetTitle(node, title); | |
| 291 } | |
| 292 | |
| 293 void BookmarkModelVerifier::SetFavicon( | |
| 294 BookmarkModel* model, | |
| 295 const BookmarkNode* node, | |
| 296 const std::vector<unsigned char>& icon_bytes_vector) { | |
| 297 urls_with_favicons_.insert(node->GetURL()); | |
| 298 if (use_verifier_model_) { | |
| 299 const BookmarkNode* v_node = NULL; | |
| 300 FindNodeInVerifier(model, node, &v_node); | |
| 301 FaviconChangeObserver v_observer(verifier_model_, v_node); | |
| 302 browser_sync::BookmarkChangeProcessor::ApplyBookmarkFavicon( | |
| 303 v_node, verifier_model_->profile(), icon_bytes_vector); | |
| 304 v_observer.WaitForSetFavicon(); | |
| 305 } | |
| 306 FaviconChangeObserver observer(model, node); | |
| 307 browser_sync::BookmarkChangeProcessor::ApplyBookmarkFavicon( | |
| 308 node, model->profile(), icon_bytes_vector); | |
| 309 observer.WaitForSetFavicon(); | |
| 310 } | |
| 311 | |
| 312 const SkBitmap& BookmarkModelVerifier::GetFavicon( | |
| 313 BookmarkModel* model, | |
| 314 const BookmarkNode* node) const { | |
| 315 // If a favicon wasn't explicitly set for a particular URL, simply return its | |
| 316 // blank favicon. | |
| 317 if (urls_with_favicons_.find(node->GetURL()) == urls_with_favicons_.end()) { | |
| 318 return node->favicon(); | |
| 319 } | |
| 320 // If a favicon was explicitly set, we may need to wait for it to be loaded | |
| 321 // via BookmarkModel::GetFavIcon(), which is an asynchronous operation. | |
| 322 if (!node->is_favicon_loaded()) { | |
| 323 FaviconChangeObserver observer(model, node); | |
| 324 model->GetFavicon(node); | |
| 325 observer.WaitForGetFavicon(); | |
| 326 } | |
| 327 EXPECT_TRUE(node->is_favicon_loaded()); | |
| 328 return node->favicon(); | |
| 329 } | |
| 330 | |
| 331 void BookmarkModelVerifier::Move(BookmarkModel* model, | |
| 332 const BookmarkNode* node, | |
| 333 const BookmarkNode* new_parent, | |
| 334 int index) { | |
| 335 if (use_verifier_model_) { | |
| 336 const BookmarkNode* v_new_parent = NULL; | |
| 337 const BookmarkNode* v_node = NULL; | |
| 338 FindNodeInVerifier(model, new_parent, &v_new_parent); | |
| 339 FindNodeInVerifier(model, node, &v_node); | |
| 340 verifier_model_->Move(v_node, v_new_parent, index); | |
| 341 } | |
| 342 model->Move(node, new_parent, index); | |
| 343 } | |
| 344 | |
| 345 void BookmarkModelVerifier::Remove(BookmarkModel* model, | |
| 346 const BookmarkNode* parent, | |
| 347 int index) { | |
| 348 if (use_verifier_model_) { | |
| 349 const BookmarkNode* v_parent = NULL; | |
| 350 FindNodeInVerifier(model, parent, &v_parent); | |
| 351 ASSERT_TRUE(NodesMatch(parent->GetChild(index), v_parent->GetChild(index))); | |
| 352 verifier_model_->Remove(v_parent, index); | |
| 353 } | |
| 354 model->Remove(parent, index); | |
| 355 } | |
| 356 | |
| 357 void BookmarkModelVerifier::SortChildren(BookmarkModel* model, | |
| 358 const BookmarkNode* parent) { | |
| 359 if (use_verifier_model_) { | |
| 360 const BookmarkNode* v_parent = NULL; | |
| 361 FindNodeInVerifier(model, parent, &v_parent); | |
| 362 verifier_model_->SortChildren(v_parent); | |
| 363 } | |
| 364 model->SortChildren(parent); | |
| 365 } | |
| 366 | |
| 367 void BookmarkModelVerifier::ReverseChildOrder(BookmarkModel* model, | |
| 368 const BookmarkNode* parent) { | |
| 369 int child_count = parent->child_count(); | |
| 370 if (child_count <= 0) | |
| 371 return; | |
| 372 for (int index = 0; index < child_count; index++) | |
| 373 Move(model, parent->GetChild(index), parent, child_count-index); | |
| 374 } | |
| 375 | |
| 376 const BookmarkNode* BookmarkModelVerifier::SetURL(BookmarkModel* model, | |
| 377 const BookmarkNode* node, | |
| 378 const GURL& new_url) { | |
| 379 if (use_verifier_model_) { | |
| 380 const BookmarkNode* v_node = NULL; | |
| 381 FindNodeInVerifier(model, node, &v_node); | |
| 382 bookmark_utils::ApplyEditsWithNoFolderChange( | |
| 383 verifier_model_, v_node->parent(), | |
| 384 BookmarkEditor::EditDetails(v_node), v_node->GetTitle(), new_url); | |
| 385 } | |
| 386 return bookmark_utils::ApplyEditsWithNoFolderChange( | |
| 387 model, node->parent(), BookmarkEditor::EditDetails(node), | |
| 388 node->GetTitle(), new_url); | |
| 389 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 7259005:
Allow sync integration tests to operate on multiple datatypes: Preferences + Bookmarks (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src