| 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, bool ids_reassigned) 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->url() != node_b->url()) { | |
| 103 LOG(ERROR) << "URL mismatch: " << node_a->url() << " vs. " << node_b->url(); | |
| 104 return false; | |
| 105 } | |
| 106 if (node_a->parent()->GetIndexOf(node_a) != | |
| 107 node_b->parent()->GetIndexOf(node_b)) { | |
| 108 LOG(ERROR) << "Index mismatch: " | |
| 109 << node_a->parent()->GetIndexOf(node_a) << " vs. " | |
| 110 << node_b->parent()->GetIndexOf(node_b); | |
| 111 return false; | |
| 112 } | |
| 113 return true; | |
| 114 } | |
| 115 | |
| 116 bool BookmarkModelVerifier::ModelsMatch(BookmarkModel* model_a, | |
| 117 BookmarkModel* model_b) const { | |
| 118 bool ret_val = true; | |
| 119 ui::TreeNodeIterator<const BookmarkNode> iterator_a(model_a->root_node()); | |
| 120 ui::TreeNodeIterator<const BookmarkNode> iterator_b(model_b->root_node()); | |
| 121 while (iterator_a.has_next()) { | |
| 122 const BookmarkNode* node_a = iterator_a.Next(); | |
| 123 if (!iterator_b.has_next()) { | |
| 124 LOG(ERROR) << "Models do not match."; | |
| 125 return false; | |
| 126 } | |
| 127 const BookmarkNode* node_b = iterator_b.Next(); | |
| 128 ret_val = ret_val && NodesMatch(node_a, node_b); | |
| 129 if (node_a->is_folder() || node_b->is_folder()) | |
| 130 continue; | |
| 131 ret_val = ret_val && FaviconsMatch(model_a, model_b, node_a, node_b); | |
| 132 } | |
| 133 ret_val = ret_val && (!iterator_b.has_next()); | |
| 134 return ret_val; | |
| 135 } | |
| 136 | |
| 137 bool BookmarkModelVerifier::FaviconsMatch(BookmarkModel* model_a, | |
| 138 BookmarkModel* model_b, | |
| 139 const BookmarkNode* node_a, | |
| 140 const BookmarkNode* node_b) const { | |
| 141 const SkBitmap& bitmap_a = GetFavicon(model_a, node_a); | |
| 142 const SkBitmap& bitmap_b = GetFavicon(model_b, node_b); | |
| 143 return FaviconBitmapsMatch(bitmap_a, bitmap_b); | |
| 144 } | |
| 145 | |
| 146 bool BookmarkModelVerifier::FaviconBitmapsMatch( | |
| 147 const SkBitmap& bitmap_a, | |
| 148 const SkBitmap& bitmap_b) const { | |
| 149 if (bitmap_a.getSize() == 0U && bitmap_a.getSize() == 0U) | |
| 150 return true; | |
| 151 if ((bitmap_a.getSize() != bitmap_b.getSize()) || | |
| 152 (bitmap_a.width() != bitmap_b.width()) || | |
| 153 (bitmap_a.height() != bitmap_b.height())) { | |
| 154 LOG(ERROR) << "Favicon size mismatch: " << bitmap_a.getSize() << " (" | |
| 155 << bitmap_a.width() << "x" << bitmap_a.height() << ") vs. " | |
| 156 << bitmap_b.getSize() << " (" << bitmap_b.width() << "x" | |
| 157 << bitmap_b.height() << ")"; | |
| 158 return false; | |
| 159 } | |
| 160 SkAutoLockPixels bitmap_lock_a(bitmap_a); | |
| 161 SkAutoLockPixels bitmap_lock_b(bitmap_b); | |
| 162 void* node_pixel_addr_a = bitmap_a.getPixels(); | |
| 163 EXPECT_TRUE(node_pixel_addr_a); | |
| 164 void* node_pixel_addr_b = bitmap_b.getPixels(); | |
| 165 EXPECT_TRUE(node_pixel_addr_b); | |
| 166 if (memcmp(node_pixel_addr_a, node_pixel_addr_b, bitmap_a.getSize()) != 0) { | |
| 167 LOG(ERROR) << "Favicon bitmap mismatch"; | |
| 168 return false; | |
| 169 } else { | |
| 170 return true; | |
| 171 } | |
| 172 } | |
| 173 | |
| 174 bool BookmarkModelVerifier::ContainsDuplicateBookmarks( | |
| 175 BookmarkModel* model) const { | |
| 176 ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node()); | |
| 177 while (iterator.has_next()) { | |
| 178 const BookmarkNode* node = iterator.Next(); | |
| 179 if (node->is_folder()) | |
| 180 continue; | |
| 181 std::vector<const BookmarkNode*> nodes; | |
| 182 model->GetNodesByURL(node->url(), &nodes); | |
| 183 EXPECT_TRUE(nodes.size() >= 1); | |
| 184 for (std::vector<const BookmarkNode*>::const_iterator it = nodes.begin(); | |
| 185 it != nodes.end(); ++it) { | |
| 186 if (node->id() != (*it)->id() && | |
| 187 node->parent() == (*it)->parent() && | |
| 188 node->GetTitle() == (*it)->GetTitle()){ | |
| 189 return true; | |
| 190 } | |
| 191 } | |
| 192 } | |
| 193 return false; | |
| 194 } | |
| 195 | |
| 196 int BookmarkModelVerifier::CountNodesWithTitlesMatching( | |
| 197 BookmarkModel* model, | |
| 198 BookmarkNode::Type node_type, | |
| 199 const string16& title) const { | |
| 200 ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node()); | |
| 201 // Walk through the model tree looking for bookmark nodes of node type | |
| 202 // |node_type| whose titles match |title|. | |
| 203 int count = 0; | |
| 204 while (iterator.has_next()) { | |
| 205 const BookmarkNode* node = iterator.Next(); | |
| 206 if ((node->type() == node_type) && (node->GetTitle() == title)) | |
| 207 ++count; | |
| 208 } | |
| 209 return count; | |
| 210 } | |
| 211 | |
| 212 void BookmarkModelVerifier::FindNodeInVerifier(BookmarkModel* foreign_model, | |
| 213 const BookmarkNode* foreign_node, | |
| 214 const BookmarkNode** result) { | |
| 215 // Climb the tree. | |
| 216 std::stack<int> path; | |
| 217 const BookmarkNode* walker = foreign_node; | |
| 218 while (walker != foreign_model->root_node()) { | |
| 219 path.push(walker->parent()->GetIndexOf(walker)); | |
| 220 walker = walker->parent(); | |
| 221 } | |
| 222 | |
| 223 // Swing over to the other tree. | |
| 224 walker = verifier_model_->root_node(); | |
| 225 | |
| 226 // Climb down. | |
| 227 while (!path.empty()) { | |
| 228 ASSERT_TRUE(walker->is_folder()); | |
| 229 ASSERT_LT(path.top(), walker->child_count()); | |
| 230 walker = walker->GetChild(path.top()); | |
| 231 path.pop(); | |
| 232 } | |
| 233 | |
| 234 ASSERT_TRUE(NodesMatch(foreign_node, walker)); | |
| 235 *result = walker; | |
| 236 } | |
| 237 | |
| 238 const BookmarkNode* BookmarkModelVerifier::AddFolder(BookmarkModel* model, | |
| 239 const BookmarkNode* parent, | |
| 240 int index, | |
| 241 const string16& title) { | |
| 242 const BookmarkNode* result = model->AddFolder(parent, index, title); | |
| 243 EXPECT_TRUE(result); | |
| 244 if (!result) | |
| 245 return NULL; | |
| 246 if (use_verifier_model_) { | |
| 247 const BookmarkNode* v_parent = NULL; | |
| 248 FindNodeInVerifier(model, parent, &v_parent); | |
| 249 const BookmarkNode* v_node = verifier_model_->AddFolder( | |
| 250 v_parent, index, title); | |
| 251 EXPECT_TRUE(v_node); | |
| 252 if (!v_node) | |
| 253 return NULL; | |
| 254 EXPECT_TRUE(NodesMatch(v_node, result)); | |
| 255 } | |
| 256 return result; | |
| 257 } | |
| 258 | |
| 259 const BookmarkNode* BookmarkModelVerifier::AddURL(BookmarkModel* model, | |
| 260 const BookmarkNode* parent, | |
| 261 int index, | |
| 262 const string16& title, | |
| 263 const GURL& url) { | |
| 264 const BookmarkNode* result = model->AddURL(parent, index, title, url); | |
| 265 EXPECT_TRUE(result); | |
| 266 if (!result) | |
| 267 return NULL; | |
| 268 if (use_verifier_model_) { | |
| 269 const BookmarkNode* v_parent = NULL; | |
| 270 FindNodeInVerifier(model, parent, &v_parent); | |
| 271 const BookmarkNode* v_node = | |
| 272 verifier_model_->AddURL(v_parent, index, title, url); | |
| 273 EXPECT_TRUE(v_node); | |
| 274 if (!v_node) | |
| 275 return NULL; | |
| 276 EXPECT_TRUE(NodesMatch(v_node, result)); | |
| 277 } | |
| 278 return result; | |
| 279 } | |
| 280 | |
| 281 void BookmarkModelVerifier::SetTitle(BookmarkModel* model, | |
| 282 const BookmarkNode* node, | |
| 283 const string16& title) { | |
| 284 if (use_verifier_model_) { | |
| 285 const BookmarkNode* v_node = NULL; | |
| 286 FindNodeInVerifier(model, node, &v_node); | |
| 287 verifier_model_->SetTitle(v_node, title); | |
| 288 } | |
| 289 model->SetTitle(node, title); | |
| 290 } | |
| 291 | |
| 292 void BookmarkModelVerifier::SetFavicon( | |
| 293 BookmarkModel* model, | |
| 294 const BookmarkNode* node, | |
| 295 const std::vector<unsigned char>& icon_bytes_vector) { | |
| 296 urls_with_favicons_.insert(node->url()); | |
| 297 if (use_verifier_model_) { | |
| 298 const BookmarkNode* v_node = NULL; | |
| 299 FindNodeInVerifier(model, node, &v_node); | |
| 300 FaviconChangeObserver v_observer(verifier_model_, v_node); | |
| 301 browser_sync::BookmarkChangeProcessor::ApplyBookmarkFavicon( | |
| 302 v_node, verifier_model_->profile(), icon_bytes_vector); | |
| 303 v_observer.WaitForSetFavicon(); | |
| 304 } | |
| 305 FaviconChangeObserver observer(model, node); | |
| 306 browser_sync::BookmarkChangeProcessor::ApplyBookmarkFavicon( | |
| 307 node, model->profile(), icon_bytes_vector); | |
| 308 observer.WaitForSetFavicon(); | |
| 309 } | |
| 310 | |
| 311 const SkBitmap& BookmarkModelVerifier::GetFavicon( | |
| 312 BookmarkModel* model, | |
| 313 const BookmarkNode* node) const { | |
| 314 // If a favicon wasn't explicitly set for a particular URL, simply return its | |
| 315 // blank favicon. | |
| 316 if (urls_with_favicons_.find(node->url()) == urls_with_favicons_.end()) { | |
| 317 return node->favicon(); | |
| 318 } | |
| 319 // If a favicon was explicitly set, we may need to wait for it to be loaded | |
| 320 // via BookmarkModel::GetFavIcon(), which is an asynchronous operation. | |
| 321 if (!node->is_favicon_loaded()) { | |
| 322 FaviconChangeObserver observer(model, node); | |
| 323 model->GetFavicon(node); | |
| 324 observer.WaitForGetFavicon(); | |
| 325 } | |
| 326 EXPECT_TRUE(node->is_favicon_loaded()); | |
| 327 return node->favicon(); | |
| 328 } | |
| 329 | |
| 330 void BookmarkModelVerifier::Move(BookmarkModel* model, | |
| 331 const BookmarkNode* node, | |
| 332 const BookmarkNode* new_parent, | |
| 333 int index) { | |
| 334 if (use_verifier_model_) { | |
| 335 const BookmarkNode* v_new_parent = NULL; | |
| 336 const BookmarkNode* v_node = NULL; | |
| 337 FindNodeInVerifier(model, new_parent, &v_new_parent); | |
| 338 FindNodeInVerifier(model, node, &v_node); | |
| 339 verifier_model_->Move(v_node, v_new_parent, index); | |
| 340 } | |
| 341 model->Move(node, new_parent, index); | |
| 342 } | |
| 343 | |
| 344 void BookmarkModelVerifier::Remove(BookmarkModel* model, | |
| 345 const BookmarkNode* parent, | |
| 346 int index) { | |
| 347 if (use_verifier_model_) { | |
| 348 const BookmarkNode* v_parent = NULL; | |
| 349 FindNodeInVerifier(model, parent, &v_parent); | |
| 350 ASSERT_TRUE(NodesMatch(parent->GetChild(index), v_parent->GetChild(index))); | |
| 351 verifier_model_->Remove(v_parent, index); | |
| 352 } | |
| 353 model->Remove(parent, index); | |
| 354 } | |
| 355 | |
| 356 void BookmarkModelVerifier::SortChildren(BookmarkModel* model, | |
| 357 const BookmarkNode* parent) { | |
| 358 if (use_verifier_model_) { | |
| 359 const BookmarkNode* v_parent = NULL; | |
| 360 FindNodeInVerifier(model, parent, &v_parent); | |
| 361 verifier_model_->SortChildren(v_parent); | |
| 362 } | |
| 363 model->SortChildren(parent); | |
| 364 } | |
| 365 | |
| 366 void BookmarkModelVerifier::ReverseChildOrder(BookmarkModel* model, | |
| 367 const BookmarkNode* parent) { | |
| 368 int child_count = parent->child_count(); | |
| 369 if (child_count <= 0) | |
| 370 return; | |
| 371 for (int index = 0; index < child_count; index++) | |
| 372 Move(model, parent->GetChild(index), parent, child_count-index); | |
| 373 } | |
| 374 | |
| 375 const BookmarkNode* BookmarkModelVerifier::SetURL(BookmarkModel* model, | |
| 376 const BookmarkNode* node, | |
| 377 const GURL& new_url) { | |
| 378 if (use_verifier_model_) { | |
| 379 const BookmarkNode* v_node = NULL; | |
| 380 FindNodeInVerifier(model, node, &v_node); | |
| 381 bookmark_utils::ApplyEditsWithNoFolderChange( | |
| 382 verifier_model_, v_node->parent(), | |
| 383 BookmarkEditor::EditDetails(v_node), v_node->GetTitle(), new_url); | |
| 384 } | |
| 385 return bookmark_utils::ApplyEditsWithNoFolderChange( | |
| 386 model, node->parent(), BookmarkEditor::EditDetails(node), | |
| 387 node->GetTitle(), new_url); | |
| 388 } | |
| 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