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 <set>
6#include <string>
7
8#include "base/base_paths.h"
9#include "base/file_util.h"
10#include "base/hash_tables.h"
11#include "base/path_service.h"
12#include "base/string16.h"
13#include "base/string_number_conversions.h"
14#include "base/string_split.h"
15#include "base/string_util.h"
16#include "base/utf_string_conversions.h"
17#include "chrome/browser/bookmarks/bookmark_codec.h"
18#include "chrome/browser/bookmarks/bookmark_model.h"
19#include "chrome/browser/bookmarks/bookmark_utils.h"
20#include "chrome/browser/history/history_notifications.h"
21#include "chrome/common/chrome_constants.h"
22#include "chrome/common/chrome_paths.h"
23#include "chrome/test/model_test_utils.h"
24#include "chrome/test/testing_browser_process_test.h"
25#include "chrome/test/testing_profile.h"
26#include "content/browser/browser_thread.h"
27#include "content/common/notification_details.h"
28#include "content/common/notification_registrar.h"
29#include "content/common/notification_source.h"
30#include "testing/gtest/include/gtest/gtest.h"
31#include "ui/base/models/tree_node_iterator.h"
32#include "ui/base/models/tree_node_model.h"
33
34using base::Time;
35using base::TimeDelta;
36
37namespace {
38
39// Helper to get a mutable bookmark node.
40static BookmarkNode* AsMutable(const BookmarkNode* node) {
41  return const_cast<BookmarkNode*>(node);
42}
43
44void SwapDateAdded(BookmarkNode* n1, BookmarkNode* n2) {
45  Time tmp = n1->date_added();
46  n1->set_date_added(n2->date_added());
47  n2->set_date_added(tmp);
48}
49
50}  // anonymous namespace
51
52class BookmarkModelTest : public TestingBrowserProcessTest,
53                          public BookmarkModelObserver {
54 public:
55  struct ObserverDetails {
56    ObserverDetails() {
57      Set(NULL, NULL, -1, -1);
58    }
59
60    void Set(const BookmarkNode* node1,
61             const BookmarkNode* node2,
62             int index1,
63             int index2) {
64      this->node1 = node1;
65      this->node2 = node2;
66      this->index1 = index1;
67      this->index2 = index2;
68    }
69
70    void AssertEquals(const BookmarkNode* node1,
71                      const BookmarkNode* node2,
72                      int index1,
73                      int index2) {
74      ASSERT_TRUE(this->node1 == node1);
75      ASSERT_TRUE(this->node2 == node2);
76      ASSERT_EQ(index1, this->index1);
77      ASSERT_EQ(index2, this->index2);
78    }
79
80    const BookmarkNode* node1;
81    const BookmarkNode* node2;
82    int index1;
83    int index2;
84  };
85
86  BookmarkModelTest() : model(NULL) {
87    model.AddObserver(this);
88    ClearCounts();
89  }
90
91
92  void Loaded(BookmarkModel* model) {
93    // We never load from the db, so that this should never get invoked.
94    NOTREACHED();
95  }
96
97  virtual void BookmarkNodeMoved(BookmarkModel* model,
98                                 const BookmarkNode* old_parent,
99                                 int old_index,
100                                 const BookmarkNode* new_parent,
101                                 int new_index) {
102    moved_count++;
103    observer_details.Set(old_parent, new_parent, old_index, new_index);
104  }
105
106  virtual void BookmarkNodeAdded(BookmarkModel* model,
107                                 const BookmarkNode* parent,
108                                 int index) {
109    added_count++;
110    observer_details.Set(parent, NULL, index, -1);
111  }
112
113  virtual void BookmarkNodeRemoved(BookmarkModel* model,
114                                   const BookmarkNode* parent,
115                                   int old_index,
116                                   const BookmarkNode* node) {
117    removed_count++;
118    observer_details.Set(parent, NULL, old_index, -1);
119  }
120
121  virtual void BookmarkNodeChanged(BookmarkModel* model,
122                                   const BookmarkNode* node) {
123    changed_count++;
124    observer_details.Set(node, NULL, -1, -1);
125  }
126
127  virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
128                                             const BookmarkNode* node) {
129    reordered_count_++;
130  }
131
132  virtual void BookmarkNodeFaviconLoaded(BookmarkModel* model,
133                                         const BookmarkNode* node) {
134    // We never attempt to load favicons, so that this method never
135    // gets invoked.
136  }
137
138  void ClearCounts() {
139    reordered_count_ = moved_count = added_count = removed_count =
140        changed_count = 0;
141  }
142
143  void AssertObserverCount(int added_count,
144                           int moved_count,
145                           int removed_count,
146                           int changed_count,
147                           int reordered_count) {
148    ASSERT_EQ(added_count, this->added_count);
149    ASSERT_EQ(moved_count, this->moved_count);
150    ASSERT_EQ(removed_count, this->removed_count);
151    ASSERT_EQ(changed_count, this->changed_count);
152    ASSERT_EQ(reordered_count, reordered_count_);
153  }
154
155  BookmarkModel model;
156
157  int moved_count;
158
159  int added_count;
160
161  int removed_count;
162
163  int changed_count;
164
165  int reordered_count_;
166
167  ObserverDetails observer_details;
168};
169
170TEST_F(BookmarkModelTest, InitialState) {
171  const BookmarkNode* bb_node = model.GetBookmarkBarNode();
172  ASSERT_TRUE(bb_node != NULL);
173  EXPECT_EQ(0, bb_node->child_count());
174  EXPECT_EQ(BookmarkNode::BOOKMARK_BAR, bb_node->type());
175
176  const BookmarkNode* other_node = model.other_node();
177  ASSERT_TRUE(other_node != NULL);
178  EXPECT_EQ(0, other_node->child_count());
179  EXPECT_EQ(BookmarkNode::OTHER_NODE, other_node->type());
180
181  EXPECT_TRUE(bb_node->id() != other_node->id());
182}
183
184TEST_F(BookmarkModelTest, AddURL) {
185  const BookmarkNode* root = model.GetBookmarkBarNode();
186  const string16 title(ASCIIToUTF16("foo"));
187  const GURL url("http://foo.com");
188
189  const BookmarkNode* new_node = model.AddURL(root, 0, title, url);
190  AssertObserverCount(1, 0, 0, 0, 0);
191  observer_details.AssertEquals(root, NULL, 0, -1);
192
193  ASSERT_EQ(1, root->child_count());
194  ASSERT_EQ(title, new_node->GetTitle());
195  ASSERT_TRUE(url == new_node->GetURL());
196  ASSERT_EQ(BookmarkNode::URL, new_node->type());
197  ASSERT_TRUE(new_node == model.GetMostRecentlyAddedNodeForURL(url));
198
199  EXPECT_TRUE(new_node->id() != root->id() &&
200              new_node->id() != model.other_node()->id());
201}
202
203TEST_F(BookmarkModelTest, AddFolder) {
204  const BookmarkNode* root = model.GetBookmarkBarNode();
205  const string16 title(ASCIIToUTF16("foo"));
206
207  const BookmarkNode* new_node = model.AddFolder(root, 0, title);
208  AssertObserverCount(1, 0, 0, 0, 0);
209  observer_details.AssertEquals(root, NULL, 0, -1);
210
211  ASSERT_EQ(1, root->child_count());
212  ASSERT_EQ(title, new_node->GetTitle());
213  ASSERT_EQ(BookmarkNode::FOLDER, new_node->type());
214
215  EXPECT_TRUE(new_node->id() != root->id() &&
216              new_node->id() != model.other_node()->id());
217
218  // Add another folder, just to make sure folder_ids are incremented correctly.
219  ClearCounts();
220  model.AddFolder(root, 0, title);
221  AssertObserverCount(1, 0, 0, 0, 0);
222  observer_details.AssertEquals(root, NULL, 0, -1);
223}
224
225TEST_F(BookmarkModelTest, RemoveURL) {
226  const BookmarkNode* root = model.GetBookmarkBarNode();
227  const string16 title(ASCIIToUTF16("foo"));
228  const GURL url("http://foo.com");
229  model.AddURL(root, 0, title, url);
230  ClearCounts();
231
232  model.Remove(root, 0);
233  ASSERT_EQ(0, root->child_count());
234  AssertObserverCount(0, 0, 1, 0, 0);
235  observer_details.AssertEquals(root, NULL, 0, -1);
236
237  // Make sure there is no mapping for the URL.
238  ASSERT_TRUE(model.GetMostRecentlyAddedNodeForURL(url) == NULL);
239}
240
241TEST_F(BookmarkModelTest, RemoveFolder) {
242  const BookmarkNode* root = model.GetBookmarkBarNode();
243  const BookmarkNode* folder = model.AddFolder(root, 0, ASCIIToUTF16("foo"));
244
245  ClearCounts();
246
247  // Add a URL as a child.
248  const string16 title(ASCIIToUTF16("foo"));
249  const GURL url("http://foo.com");
250  model.AddURL(folder, 0, title, url);
251
252  ClearCounts();
253
254  // Now remove the folder.
255  model.Remove(root, 0);
256  ASSERT_EQ(0, root->child_count());
257  AssertObserverCount(0, 0, 1, 0, 0);
258  observer_details.AssertEquals(root, NULL, 0, -1);
259
260  // Make sure there is no mapping for the URL.
261  ASSERT_TRUE(model.GetMostRecentlyAddedNodeForURL(url) == NULL);
262}
263
264TEST_F(BookmarkModelTest, SetTitle) {
265  const BookmarkNode* root = model.GetBookmarkBarNode();
266  string16 title(ASCIIToUTF16("foo"));
267  const GURL url("http://foo.com");
268  const BookmarkNode* node = model.AddURL(root, 0, title, url);
269
270  ClearCounts();
271
272  title = ASCIIToUTF16("foo2");
273  model.SetTitle(node, title);
274  AssertObserverCount(0, 0, 0, 1, 0);
275  observer_details.AssertEquals(node, NULL, -1, -1);
276  EXPECT_EQ(title, node->GetTitle());
277}
278
279TEST_F(BookmarkModelTest, SetURL) {
280  const BookmarkNode* root = model.GetBookmarkBarNode();
281  const string16 title(ASCIIToUTF16("foo"));
282  GURL url("http://foo.com");
283  const BookmarkNode* node = model.AddURL(root, 0, title, url);
284
285  ClearCounts();
286
287  url = GURL("http://foo2.com");
288  model.SetURL(node, url);
289  AssertObserverCount(0, 0, 0, 1, 0);
290  observer_details.AssertEquals(node, NULL, -1, -1);
291  EXPECT_EQ(url, node->GetURL());
292}
293
294TEST_F(BookmarkModelTest, Move) {
295  const BookmarkNode* root = model.GetBookmarkBarNode();
296  const string16 title(ASCIIToUTF16("foo"));
297  const GURL url("http://foo.com");
298  const BookmarkNode* node = model.AddURL(root, 0, title, url);
299  const BookmarkNode* folder1 = model.AddFolder(root, 0, ASCIIToUTF16("foo"));
300  ClearCounts();
301
302  model.Move(node, folder1, 0);
303
304  AssertObserverCount(0, 1, 0, 0, 0);
305  observer_details.AssertEquals(root, folder1, 1, 0);
306  EXPECT_TRUE(folder1 == node->parent());
307  EXPECT_EQ(1, root->child_count());
308  EXPECT_EQ(folder1, root->GetChild(0));
309  EXPECT_EQ(1, folder1->child_count());
310  EXPECT_EQ(node, folder1->GetChild(0));
311
312  // And remove the folder.
313  ClearCounts();
314  model.Remove(root, 0);
315  AssertObserverCount(0, 0, 1, 0, 0);
316  observer_details.AssertEquals(root, NULL, 0, -1);
317  EXPECT_TRUE(model.GetMostRecentlyAddedNodeForURL(url) == NULL);
318  EXPECT_EQ(0, root->child_count());
319}
320
321TEST_F(BookmarkModelTest, Copy) {
322  const BookmarkNode* root = model.GetBookmarkBarNode();
323  static const std::string model_string("a 1:[ b c ] d 2:[ e f g ] h ");
324  model_test_utils::AddNodesFromModelString(model, root, model_string);
325
326  // Validate initial model.
327  std::string actualModelString = model_test_utils::ModelStringFromNode(root);
328  EXPECT_EQ(model_string, actualModelString);
329
330  // Copy 'd' to be after '1:b': URL item from bar to folder.
331  const BookmarkNode* nodeToCopy = root->GetChild(2);
332  const BookmarkNode* destination = root->GetChild(1);
333  model.Copy(nodeToCopy, destination, 1);
334  actualModelString = model_test_utils::ModelStringFromNode(root);
335  EXPECT_EQ("a 1:[ b d c ] d 2:[ e f g ] h ", actualModelString);
336
337  // Copy '1:d' to be after 'a': URL item from folder to bar.
338  const BookmarkNode* folder = root->GetChild(1);
339  nodeToCopy = folder->GetChild(1);
340  model.Copy(nodeToCopy, root, 1);
341  actualModelString = model_test_utils::ModelStringFromNode(root);
342  EXPECT_EQ("a d 1:[ b d c ] d 2:[ e f g ] h ", actualModelString);
343
344  // Copy '1' to be after '2:e': Folder from bar to folder.
345  nodeToCopy = root->GetChild(2);
346  destination = root->GetChild(4);
347  model.Copy(nodeToCopy, destination, 1);
348  actualModelString = model_test_utils::ModelStringFromNode(root);
349  EXPECT_EQ("a d 1:[ b d c ] d 2:[ e 1:[ b d c ] f g ] h ", actualModelString);
350
351  // Copy '2:1' to be after '2:f': Folder within same folder.
352  folder = root->GetChild(4);
353  nodeToCopy = folder->GetChild(1);
354  model.Copy(nodeToCopy, folder, 3);
355  actualModelString = model_test_utils::ModelStringFromNode(root);
356  EXPECT_EQ("a d 1:[ b d c ] d 2:[ e 1:[ b d c ] f 1:[ b d c ] g ] h ",
357            actualModelString);
358
359  // Copy first 'd' to be after 'h': URL item within the bar.
360  nodeToCopy = root->GetChild(1);
361  model.Copy(nodeToCopy, root, 6);
362  actualModelString = model_test_utils::ModelStringFromNode(root);
363  EXPECT_EQ("a d 1:[ b d c ] d 2:[ e 1:[ b d c ] f 1:[ b d c ] g ] h d ",
364            actualModelString);
365
366  // Copy '2' to be after 'a': Folder within the bar.
367  nodeToCopy = root->GetChild(4);
368  model.Copy(nodeToCopy, root, 1);
369  actualModelString = model_test_utils::ModelStringFromNode(root);
370  EXPECT_EQ("a 2:[ e 1:[ b d c ] f 1:[ b d c ] g ] d 1:[ b d c ] "
371            "d 2:[ e 1:[ b d c ] f 1:[ b d c ] g ] h d ",
372            actualModelString);
373}
374
375// Tests that adding a URL to a folder updates the last modified time.
376TEST_F(BookmarkModelTest, ParentForNewNodes) {
377  ASSERT_EQ(model.GetBookmarkBarNode(), model.GetParentForNewNodes());
378
379  const string16 title(ASCIIToUTF16("foo"));
380  const GURL url("http://foo.com");
381
382  model.AddURL(model.other_node(), 0, title, url);
383  ASSERT_EQ(model.other_node(), model.GetParentForNewNodes());
384}
385
386// Make sure recently modified stays in sync when adding a URL.
387TEST_F(BookmarkModelTest, MostRecentlyModifiedFolders) {
388  // Add a folder.
389  const BookmarkNode* folder = model.AddFolder(model.other_node(), 0,
390                                               ASCIIToUTF16("foo"));
391  // Add a URL to it.
392  model.AddURL(folder, 0, ASCIIToUTF16("blah"), GURL("http://foo.com"));
393
394  // Make sure folder is in the most recently modified.
395  std::vector<const BookmarkNode*> most_recent_folders =
396      bookmark_utils::GetMostRecentlyModifiedFolders(&model, 1);
397  ASSERT_EQ(1U, most_recent_folders.size());
398  ASSERT_EQ(folder, most_recent_folders[0]);
399
400  // Nuke the folder and do another fetch, making sure folder isn't in the
401  // returned list.
402  model.Remove(folder->parent(), 0);
403  most_recent_folders =
404      bookmark_utils::GetMostRecentlyModifiedFolders(&model, 1);
405  ASSERT_EQ(1U, most_recent_folders.size());
406  ASSERT_TRUE(most_recent_folders[0] != folder);
407}
408
409// Make sure MostRecentlyAddedEntries stays in sync.
410TEST_F(BookmarkModelTest, MostRecentlyAddedEntries) {
411  // Add a couple of nodes such that the following holds for the time of the
412  // nodes: n1 > n2 > n3 > n4.
413  Time base_time = Time::Now();
414  BookmarkNode* n1 = AsMutable(model.AddURL(model.GetBookmarkBarNode(),
415                                  0,
416                                  ASCIIToUTF16("blah"),
417                                  GURL("http://foo.com/0")));
418  BookmarkNode* n2 = AsMutable(model.AddURL(model.GetBookmarkBarNode(),
419                                  1,
420                                  ASCIIToUTF16("blah"),
421                                  GURL("http://foo.com/1")));
422  BookmarkNode* n3 = AsMutable(model.AddURL(model.GetBookmarkBarNode(),
423                                  2,
424                                  ASCIIToUTF16("blah"),
425                                  GURL("http://foo.com/2")));
426  BookmarkNode* n4 = AsMutable(model.AddURL(model.GetBookmarkBarNode(),
427                                  3,
428                                  ASCIIToUTF16("blah"),
429                                  GURL("http://foo.com/3")));
430  n1->set_date_added(base_time + TimeDelta::FromDays(4));
431  n2->set_date_added(base_time + TimeDelta::FromDays(3));
432  n3->set_date_added(base_time + TimeDelta::FromDays(2));
433  n4->set_date_added(base_time + TimeDelta::FromDays(1));
434
435  // Make sure order is honored.
436  std::vector<const BookmarkNode*> recently_added;
437  bookmark_utils::GetMostRecentlyAddedEntries(&model, 2, &recently_added);
438  ASSERT_EQ(2U, recently_added.size());
439  ASSERT_TRUE(n1 == recently_added[0]);
440  ASSERT_TRUE(n2 == recently_added[1]);
441
442  // swap 1 and 2, then check again.
443  recently_added.clear();
444  SwapDateAdded(n1, n2);
445  bookmark_utils::GetMostRecentlyAddedEntries(&model, 4, &recently_added);
446  ASSERT_EQ(4U, recently_added.size());
447  ASSERT_TRUE(n2 == recently_added[0]);
448  ASSERT_TRUE(n1 == recently_added[1]);
449  ASSERT_TRUE(n3 == recently_added[2]);
450  ASSERT_TRUE(n4 == recently_added[3]);
451}
452
453// Makes sure GetMostRecentlyAddedNodeForURL stays in sync.
454TEST_F(BookmarkModelTest, GetMostRecentlyAddedNodeForURL) {
455  // Add a couple of nodes such that the following holds for the time of the
456  // nodes: n1 > n2
457  Time base_time = Time::Now();
458  const GURL url("http://foo.com/0");
459  BookmarkNode* n1 = AsMutable(model.AddURL(
460      model.GetBookmarkBarNode(), 0, ASCIIToUTF16("blah"), url));
461  BookmarkNode* n2 = AsMutable(model.AddURL(
462      model.GetBookmarkBarNode(), 1, ASCIIToUTF16("blah"), url));
463  n1->set_date_added(base_time + TimeDelta::FromDays(4));
464  n2->set_date_added(base_time + TimeDelta::FromDays(3));
465
466  // Make sure order is honored.
467  ASSERT_EQ(n1, model.GetMostRecentlyAddedNodeForURL(url));
468
469  // swap 1 and 2, then check again.
470  SwapDateAdded(n1, n2);
471  ASSERT_EQ(n2, model.GetMostRecentlyAddedNodeForURL(url));
472}
473
474// Makes sure GetBookmarks removes duplicates.
475TEST_F(BookmarkModelTest, GetBookmarksWithDups) {
476  const GURL url("http://foo.com/0");
477  model.AddURL(model.GetBookmarkBarNode(), 0, ASCIIToUTF16("blah"), url);
478  model.AddURL(model.GetBookmarkBarNode(), 1, ASCIIToUTF16("blah"), url);
479
480  std::vector<GURL> urls;
481  model.GetBookmarks(&urls);
482  EXPECT_EQ(1U, urls.size());
483  ASSERT_TRUE(urls[0] == url);
484}
485
486TEST_F(BookmarkModelTest, HasBookmarks) {
487  const GURL url("http://foo.com/");
488  model.AddURL(model.GetBookmarkBarNode(), 0, ASCIIToUTF16("bar"), url);
489
490  EXPECT_TRUE(model.HasBookmarks());
491}
492
493namespace {
494
495// NotificationObserver implementation used in verifying we've received the
496// NOTIFY_URLS_STARRED method correctly.
497class StarredListener : public NotificationObserver {
498 public:
499  StarredListener() : notification_count_(0), details_(false) {
500    registrar_.Add(this, NotificationType::URLS_STARRED, Source<Profile>(NULL));
501  }
502
503  virtual void Observe(NotificationType type,
504                       const NotificationSource& source,
505                       const NotificationDetails& details) {
506    if (type == NotificationType::URLS_STARRED) {
507      notification_count_++;
508      details_ = *(Details<history::URLsStarredDetails>(details).ptr());
509    }
510  }
511
512  // Number of times NOTIFY_URLS_STARRED has been observed.
513  int notification_count_;
514
515  // Details from the last NOTIFY_URLS_STARRED.
516  history::URLsStarredDetails details_;
517
518 private:
519  NotificationRegistrar registrar_;
520
521  DISALLOW_COPY_AND_ASSIGN(StarredListener);
522};
523
524}  // namespace
525
526// Makes sure NOTIFY_URLS_STARRED is sent correctly.
527TEST_F(BookmarkModelTest, NotifyURLsStarred) {
528  StarredListener listener;
529  const GURL url("http://foo.com/0");
530  const BookmarkNode* n1 = model.AddURL(
531      model.GetBookmarkBarNode(), 0, ASCIIToUTF16("blah"), url);
532
533  // Starred notification should be sent.
534  EXPECT_EQ(1, listener.notification_count_);
535  ASSERT_TRUE(listener.details_.starred);
536  ASSERT_EQ(1U, listener.details_.changed_urls.size());
537  EXPECT_TRUE(url == *(listener.details_.changed_urls.begin()));
538  listener.notification_count_ = 0;
539  listener.details_.changed_urls.clear();
540
541  // Add another bookmark for the same URL. This should not send any
542  // notification.
543  const BookmarkNode* n2 = model.AddURL(
544      model.GetBookmarkBarNode(), 1, ASCIIToUTF16("blah"), url);
545
546  EXPECT_EQ(0, listener.notification_count_);
547
548  // Remove n2.
549  model.Remove(n2->parent(), 1);
550  n2 = NULL;
551
552  // Shouldn't have received any notification as n1 still exists with the same
553  // URL.
554  EXPECT_EQ(0, listener.notification_count_);
555
556  EXPECT_TRUE(model.GetMostRecentlyAddedNodeForURL(url) == n1);
557
558  // Remove n1.
559  model.Remove(n1->parent(), 0);
560
561  // Now we should get the notification.
562  EXPECT_EQ(1, listener.notification_count_);
563  ASSERT_FALSE(listener.details_.starred);
564  ASSERT_EQ(1U, listener.details_.changed_urls.size());
565  EXPECT_TRUE(url == *(listener.details_.changed_urls.begin()));
566}
567
568namespace {
569
570// See comment in PopulateNodeFromString.
571typedef ui::TreeNodeWithValue<BookmarkNode::Type> TestNode;
572
573// Does the work of PopulateNodeFromString. index gives the index of the current
574// element in description to process.
575static void PopulateNodeImpl(const std::vector<std::string>& description,
576                             size_t* index,
577                             TestNode* parent) {
578  while (*index < description.size()) {
579    const std::string& element = description[*index];
580    (*index)++;
581    if (element == "[") {
582      // Create a new folder and recurse to add all the children.
583      // Folders are given a unique named by way of an ever increasing integer
584      // value. The folders need not have a name, but one is assigned to help
585      // in debugging.
586      static int next_folder_id = 1;
587      TestNode* new_node =
588          new TestNode(base::IntToString16(next_folder_id++),
589                       BookmarkNode::FOLDER);
590      parent->Add(new_node, parent->child_count());
591      PopulateNodeImpl(description, index, new_node);
592    } else if (element == "]") {
593      // End the current folder.
594      return;
595    } else {
596      // Add a new URL.
597
598      // All tokens must be space separated. If there is a [ or ] in the name it
599      // likely means a space was forgotten.
600      DCHECK(element.find('[') == std::string::npos);
601      DCHECK(element.find(']') == std::string::npos);
602      parent->Add(new TestNode(UTF8ToUTF16(element), BookmarkNode::URL),
603                  parent->child_count());
604    }
605  }
606}
607
608// Creates and adds nodes to parent based on description. description consists
609// of the following tokens (all space separated):
610//   [ : creates a new USER_FOLDER node. All elements following the [ until the
611//       next balanced ] is encountered are added as children to the node.
612//   ] : closes the last folder created by [ so that any further nodes are added
613//       to the current folders parent.
614//   text: creates a new URL node.
615// For example, "a [b] c" creates the following nodes:
616//   a 1 c
617//     |
618//     b
619// In words: a node of type URL with the title a, followed by a folder node with
620// the title 1 having the single child of type url with name b, followed by
621// the url node with the title c.
622//
623// NOTE: each name must be unique, and folders are assigned a unique title by
624// way of an increasing integer.
625static void PopulateNodeFromString(const std::string& description,
626                                   TestNode* parent) {
627  std::vector<std::string> elements;
628  size_t index = 0;
629  base::SplitStringAlongWhitespace(description, &elements);
630  PopulateNodeImpl(elements, &index, parent);
631}
632
633// Populates the BookmarkNode with the children of parent.
634static void PopulateBookmarkNode(TestNode* parent,
635                                 BookmarkModel* model,
636                                 const BookmarkNode* bb_node) {
637  for (int i = 0; i < parent->child_count(); ++i) {
638    TestNode* child = parent->GetChild(i);
639    if (child->value == BookmarkNode::FOLDER) {
640      const BookmarkNode* new_bb_node =
641          model->AddFolder(bb_node, i, child->GetTitle());
642      PopulateBookmarkNode(child, model, new_bb_node);
643    } else {
644      model->AddURL(bb_node, i, child->GetTitle(),
645          GURL("http://" + UTF16ToASCII(child->GetTitle())));
646    }
647  }
648}
649
650}  // namespace
651
652// Test class that creates a BookmarkModel with a real history backend.
653class BookmarkModelTestWithProfile : public TestingBrowserProcessTest,
654                                     public BookmarkModelObserver {
655 public:
656  BookmarkModelTestWithProfile()
657      : ui_thread_(BrowserThread::UI, &message_loop_),
658        file_thread_(BrowserThread::FILE, &message_loop_) {}
659
660  virtual void SetUp() {
661  }
662
663  virtual void TearDown() {
664    profile_.reset(NULL);
665  }
666
667  // The profile.
668  scoped_ptr<TestingProfile> profile_;
669
670 protected:
671  // Verifies the contents of the bookmark bar node match the contents of the
672  // TestNode.
673  void VerifyModelMatchesNode(TestNode* expected, const BookmarkNode* actual) {
674    ASSERT_EQ(expected->child_count(), actual->child_count());
675    for (int i = 0; i < expected->child_count(); ++i) {
676      TestNode* expected_child = expected->GetChild(i);
677      const BookmarkNode* actual_child = actual->GetChild(i);
678      ASSERT_EQ(expected_child->GetTitle(), actual_child->GetTitle());
679      if (expected_child->value == BookmarkNode::FOLDER) {
680        ASSERT_TRUE(actual_child->type() == BookmarkNode::FOLDER);
681        // Recurse throught children.
682        VerifyModelMatchesNode(expected_child, actual_child);
683        if (HasFatalFailure())
684          return;
685      } else {
686        // No need to check the URL, just the title is enough.
687        ASSERT_TRUE(actual_child->type() == BookmarkNode::URL);
688      }
689    }
690  }
691
692  void VerifyNoDuplicateIDs(BookmarkModel* model) {
693    ui::TreeNodeIterator<const BookmarkNode> it(model->root_node());
694    base::hash_set<int64> ids;
695    while (it.has_next())
696      ASSERT_TRUE(ids.insert(it.Next()->id()).second);
697  }
698
699  void BlockTillBookmarkModelLoaded() {
700    bb_model_ = profile_->GetBookmarkModel();
701    if (!bb_model_->IsLoaded())
702      BlockTillLoaded(bb_model_);
703    else
704      bb_model_->AddObserver(this);
705  }
706
707  // Destroys the current profile, creates a new one and creates the history
708  // service.
709  void RecreateProfile() {
710    // Need to shutdown the old one before creating a new one.
711    profile_.reset(NULL);
712    profile_.reset(new TestingProfile());
713    profile_->CreateHistoryService(true, false);
714  }
715
716  BookmarkModel* bb_model_;
717
718 private:
719  // Blocks until the BookmarkModel has finished loading.
720  void BlockTillLoaded(BookmarkModel* model) {
721    model->AddObserver(this);
722    MessageLoop::current()->Run();
723  }
724
725  // BookmarkModelObserver methods.
726  virtual void Loaded(BookmarkModel* model) {
727    // Balances the call in BlockTillLoaded.
728    MessageLoop::current()->Quit();
729  }
730  virtual void BookmarkNodeMoved(BookmarkModel* model,
731                                 const BookmarkNode* old_parent,
732                                 int old_index,
733                                 const BookmarkNode* new_parent,
734                                 int new_index) {}
735  virtual void BookmarkNodeAdded(BookmarkModel* model,
736                                 const BookmarkNode* parent,
737                                 int index) {}
738  virtual void BookmarkNodeRemoved(BookmarkModel* model,
739                                   const BookmarkNode* parent,
740                                   int old_index,
741                                   const BookmarkNode* node) {}
742  virtual void BookmarkNodeChanged(BookmarkModel* model,
743                                   const BookmarkNode* node) {}
744  virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
745                                             const BookmarkNode* node) {}
746  virtual void BookmarkNodeFaviconLoaded(BookmarkModel* model,
747                                         const BookmarkNode* node) {}
748
749  MessageLoopForUI message_loop_;
750  BrowserThread ui_thread_;
751  BrowserThread file_thread_;
752};
753
754// Creates a set of nodes in the bookmark bar model, then recreates the
755// bookmark bar model which triggers loading from the db and checks the loaded
756// structure to make sure it is what we first created.
757TEST_F(BookmarkModelTestWithProfile, CreateAndRestore) {
758  struct TestData {
759    // Structure of the children of the bookmark bar model node.
760    const std::string bbn_contents;
761    // Structure of the children of the other node.
762    const std::string other_contents;
763  } data[] = {
764    // See PopulateNodeFromString for a description of these strings.
765    { "", "" },
766    { "a", "b" },
767    { "a [ b ]", "" },
768    { "", "[ b ] a [ c [ d e [ f ] ] ]" },
769    { "a [ b ]", "" },
770    { "a b c [ d e [ f ] ]", "g h i [ j k [ l ] ]"},
771  };
772  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
773    // Recreate the profile. We need to reset with NULL first so that the last
774    // HistoryService releases the locks on the files it creates and we can
775    // delete them.
776    profile_.reset(NULL);
777    profile_.reset(new TestingProfile());
778    profile_->CreateBookmarkModel(true);
779    profile_->CreateHistoryService(true, false);
780    BlockTillBookmarkModelLoaded();
781
782    TestNode bbn;
783    PopulateNodeFromString(data[i].bbn_contents, &bbn);
784    PopulateBookmarkNode(&bbn, bb_model_, bb_model_->GetBookmarkBarNode());
785
786    TestNode other;
787    PopulateNodeFromString(data[i].other_contents, &other);
788    PopulateBookmarkNode(&other, bb_model_, bb_model_->other_node());
789
790    profile_->CreateBookmarkModel(false);
791    BlockTillBookmarkModelLoaded();
792
793    VerifyModelMatchesNode(&bbn, bb_model_->GetBookmarkBarNode());
794    VerifyModelMatchesNode(&other, bb_model_->other_node());
795    VerifyNoDuplicateIDs(bb_model_);
796  }
797}
798
799// Test class that creates a BookmarkModel with a real history backend.
800class BookmarkModelTestWithProfile2 : public BookmarkModelTestWithProfile {
801 public:
802  virtual void SetUp() {
803    profile_.reset(new TestingProfile());
804  }
805
806 protected:
807  // Verifies the state of the model matches that of the state in the saved
808  // history file.
809  void VerifyExpectedState() {
810    // Here's the structure we expect:
811    // bbn
812    //   www.google.com - Google
813    //   F1
814    //     http://www.google.com/intl/en/ads/ - Google Advertising
815    //     F11
816    //       http://www.google.com/services/ - Google Business Solutions
817    // other
818    //   OF1
819    //   http://www.google.com/intl/en/about.html - About Google
820    const BookmarkNode* bbn = bb_model_->GetBookmarkBarNode();
821    ASSERT_EQ(2, bbn->child_count());
822
823    const BookmarkNode* child = bbn->GetChild(0);
824    ASSERT_EQ(BookmarkNode::URL, child->type());
825    ASSERT_EQ(ASCIIToUTF16("Google"), child->GetTitle());
826    ASSERT_TRUE(child->GetURL() == GURL("http://www.google.com"));
827
828    child = bbn->GetChild(1);
829    ASSERT_TRUE(child->is_folder());
830    ASSERT_EQ(ASCIIToUTF16("F1"), child->GetTitle());
831    ASSERT_EQ(2, child->child_count());
832
833    const BookmarkNode* parent = child;
834    child = parent->GetChild(0);
835    ASSERT_EQ(BookmarkNode::URL, child->type());
836    ASSERT_EQ(ASCIIToUTF16("Google Advertising"), child->GetTitle());
837    ASSERT_TRUE(child->GetURL() == GURL("http://www.google.com/intl/en/ads/"));
838
839    child = parent->GetChild(1);
840    ASSERT_TRUE(child->is_folder());
841    ASSERT_EQ(ASCIIToUTF16("F11"), child->GetTitle());
842    ASSERT_EQ(1, child->child_count());
843
844    parent = child;
845    child = parent->GetChild(0);
846    ASSERT_EQ(BookmarkNode::URL, child->type());
847    ASSERT_EQ(ASCIIToUTF16("Google Business Solutions"), child->GetTitle());
848    ASSERT_TRUE(child->GetURL() == GURL("http://www.google.com/services/"));
849
850    parent = bb_model_->other_node();
851    ASSERT_EQ(2, parent->child_count());
852
853    child = parent->GetChild(0);
854    ASSERT_TRUE(child->is_folder());
855    ASSERT_EQ(ASCIIToUTF16("OF1"), child->GetTitle());
856    ASSERT_EQ(0, child->child_count());
857
858    child = parent->GetChild(1);
859    ASSERT_EQ(BookmarkNode::URL, child->type());
860    ASSERT_EQ(ASCIIToUTF16("About Google"), child->GetTitle());
861    ASSERT_TRUE(child->GetURL() ==
862                GURL("http://www.google.com/intl/en/about.html"));
863
864    ASSERT_TRUE(bb_model_->IsBookmarked(GURL("http://www.google.com")));
865  }
866
867  void VerifyUniqueIDs() {
868    std::set<int64> ids;
869    bool has_unique = true;
870    VerifyUniqueIDImpl(bb_model_->GetBookmarkBarNode(), &ids, &has_unique);
871    VerifyUniqueIDImpl(bb_model_->other_node(), &ids, &has_unique);
872    ASSERT_TRUE(has_unique);
873  }
874
875 private:
876  void VerifyUniqueIDImpl(const BookmarkNode* node,
877                          std::set<int64>* ids,
878                          bool* has_unique) {
879    if (!*has_unique)
880      return;
881    if (ids->count(node->id()) != 0) {
882      *has_unique = false;
883      return;
884    }
885    ids->insert(node->id());
886    for (int i = 0; i < node->child_count(); ++i) {
887      VerifyUniqueIDImpl(node->GetChild(i), ids, has_unique);
888      if (!*has_unique)
889        return;
890    }
891  }
892};
893
894// Tests migrating bookmarks from db into file. This copies an old history db
895// file containing bookmarks and make sure they are loaded correctly and
896// persisted correctly.
897TEST_F(BookmarkModelTestWithProfile2, MigrateFromDBToFileTest) {
898  // Copy db file over that contains starred table.
899  FilePath old_history_path;
900  PathService::Get(chrome::DIR_TEST_DATA, &old_history_path);
901  old_history_path = old_history_path.AppendASCII("bookmarks");
902  old_history_path = old_history_path.AppendASCII("History_with_starred");
903  FilePath new_history_path = profile_->GetPath();
904  file_util::Delete(new_history_path, true);
905  file_util::CreateDirectory(new_history_path);
906  FilePath new_history_file = new_history_path.Append(
907      chrome::kHistoryFilename);
908  ASSERT_TRUE(file_util::CopyFile(old_history_path, new_history_file));
909
910  // Create the history service making sure it doesn't blow away the file we
911  // just copied.
912  profile_->CreateHistoryService(false, false);
913  profile_->CreateBookmarkModel(true);
914  BlockTillBookmarkModelLoaded();
915
916  // Make sure we loaded OK.
917  VerifyExpectedState();
918  if (HasFatalFailure())
919    return;
920
921  // Make sure the ids are unique.
922  VerifyUniqueIDs();
923  if (HasFatalFailure())
924    return;
925
926  // Create again. This time we shouldn't load from history at all.
927  profile_->CreateBookmarkModel(false);
928  BlockTillBookmarkModelLoaded();
929
930  // Make sure we loaded OK.
931  VerifyExpectedState();
932  if (HasFatalFailure())
933    return;
934
935  VerifyUniqueIDs();
936  if (HasFatalFailure())
937    return;
938
939  // Recreate the history service (with a clean db). Do this just to make sure
940  // we're loading correctly from the bookmarks file.
941  profile_->CreateHistoryService(true, false);
942  profile_->CreateBookmarkModel(false);
943  BlockTillBookmarkModelLoaded();
944  VerifyExpectedState();
945  VerifyUniqueIDs();
946}
947
948// Simple test that removes a bookmark. This test exercises the code paths in
949// History that block till bookmark bar model is loaded.
950TEST_F(BookmarkModelTestWithProfile2, RemoveNotification) {
951  profile_->CreateHistoryService(false, false);
952  profile_->CreateBookmarkModel(true);
953  BlockTillBookmarkModelLoaded();
954
955  // Add a URL.
956  GURL url("http://www.google.com");
957  bb_model_->SetURLStarred(url, string16(), true);
958
959  profile_->GetHistoryService(Profile::EXPLICIT_ACCESS)->AddPage(
960      url, NULL, 1, GURL(), PageTransition::TYPED,
961      history::RedirectList(), history::SOURCE_BROWSED, false);
962
963  // This won't actually delete the URL, rather it'll empty out the visits.
964  // This triggers blocking on the BookmarkModel.
965  profile_->GetHistoryService(Profile::EXPLICIT_ACCESS)->DeleteURL(url);
966}
967
968TEST_F(BookmarkModelTest, Sort) {
969  // Populate the bookmark bar node with nodes for 'B', 'a', 'd' and 'C'.
970  // 'C' and 'a' are folders.
971  TestNode bbn;
972  PopulateNodeFromString("B [ a ] d [ a ]", &bbn);
973  const BookmarkNode* parent = model.GetBookmarkBarNode();
974  PopulateBookmarkNode(&bbn, &model, parent);
975
976  BookmarkNode* child1 = AsMutable(parent->GetChild(1));
977  child1->set_title(ASCIIToUTF16("a"));
978  delete child1->Remove(child1->GetChild(0));
979  BookmarkNode* child3 = AsMutable(parent->GetChild(3));
980  child3->set_title(ASCIIToUTF16("C"));
981  delete child3->Remove(child3->GetChild(0));
982
983  ClearCounts();
984
985  // Sort the children of the bookmark bar node.
986  model.SortChildren(parent);
987
988  // Make sure we were notified.
989  AssertObserverCount(0, 0, 0, 0, 1);
990
991  // Make sure the order matches (remember, 'a' and 'C' are folders and
992  // come first).
993  EXPECT_EQ(parent->GetChild(0)->GetTitle(), ASCIIToUTF16("a"));
994  EXPECT_EQ(parent->GetChild(1)->GetTitle(), ASCIIToUTF16("C"));
995  EXPECT_EQ(parent->GetChild(2)->GetTitle(), ASCIIToUTF16("B"));
996  EXPECT_EQ(parent->GetChild(3)->GetTitle(), ASCIIToUTF16("d"));
997}
998