Initial implementation of "Synced Bookmarks" folder.

chrome/browser/bookmarks/bookmark_model_unittest.cc

 // Copyright (c) 2011 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 <set>
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/file_util.h"
 #include "base/hash_tables.h"
@@ skipping 160 matching lines @@
   const BookmarkNode* bb_node = model.GetBookmarkBarNode();
   ASSERT_TRUE(bb_node != NULL);
   EXPECT_EQ(0, bb_node->child_count());
   EXPECT_EQ(BookmarkNode::BOOKMARK_BAR, bb_node->type());
 
   const BookmarkNode* other_node = model.other_node();
   ASSERT_TRUE(other_node != NULL);
   EXPECT_EQ(0, other_node->child_count());
   EXPECT_EQ(BookmarkNode::OTHER_NODE, other_node->type());
 
+  const BookmarkNode* synced_node = model.synced_node();
+  ASSERT_TRUE(synced_node != NULL);
+  EXPECT_EQ(0, synced_node->child_count());
+  EXPECT_EQ(BookmarkNode::SYNCED, synced_node->type());
+
   EXPECT_TRUE(bb_node->id() != other_node->id());
+  EXPECT_TRUE(bb_node->id() != synced_node->id());
+  EXPECT_TRUE(other_node->id() != synced_node->id());
 }
 
 TEST_F(BookmarkModelTest, AddURL) {
   const BookmarkNode* root = model.GetBookmarkBarNode();
   const string16 title(ASCIIToUTF16("foo"));
   const GURL url("http://foo.com");
 
   const BookmarkNode* new_node = model.AddURL(root, 0, title, url);
   AssertObserverCount(1, 0, 0, 0, 0);
   observer_details.AssertEquals(root, NULL, 0, -1);
 
   ASSERT_EQ(1, root->child_count());
   ASSERT_EQ(title, new_node->GetTitle());
   ASSERT_TRUE(url == new_node->GetURL());
   ASSERT_EQ(BookmarkNode::URL, new_node->type());
   ASSERT_TRUE(new_node == model.GetMostRecentlyAddedNodeForURL(url));
 
   EXPECT_TRUE(new_node->id() != root->id() &&
-              new_node->id() != model.other_node()->id());
+              new_node->id() != model.other_node()->id() &&
+              new_node->id() != model.synced_node()->id());
+}
+
+TEST_F(BookmarkModelTest, AddURLToSyncedBookmarks) {
+  const BookmarkNode* root = model.synced_node();
+  const string16 title(ASCIIToUTF16("foo"));
+  const GURL url("http://foo.com");
+
+  const BookmarkNode* new_node = model.AddURL(root, 0, title, url);
+  AssertObserverCount(1, 0, 0, 0, 0);
+  observer_details.AssertEquals(root, NULL, 0, -1);
+
+  ASSERT_EQ(1, root->child_count());
+  ASSERT_EQ(title, new_node->GetTitle());
+  ASSERT_TRUE(url == new_node->GetURL());
+  ASSERT_EQ(BookmarkNode::URL, new_node->type());
+  ASSERT_TRUE(new_node == model.GetMostRecentlyAddedNodeForURL(url));
+
+  EXPECT_TRUE(new_node->id() != root->id() &&
+              new_node->id() != model.other_node()->id() &&
+              new_node->id() != model.synced_node()->id());
 }
 
 TEST_F(BookmarkModelTest, AddFolder) {
   const BookmarkNode* root = model.GetBookmarkBarNode();
   const string16 title(ASCIIToUTF16("foo"));
 
   const BookmarkNode* new_node = model.AddFolder(root, 0, title);
   AssertObserverCount(1, 0, 0, 0, 0);
   observer_details.AssertEquals(root, NULL, 0, -1);
 
   ASSERT_EQ(1, root->child_count());
   ASSERT_EQ(title, new_node->GetTitle());
   ASSERT_EQ(BookmarkNode::FOLDER, new_node->type());
 
   EXPECT_TRUE(new_node->id() != root->id() &&
-              new_node->id() != model.other_node()->id());
+              new_node->id() != model.other_node()->id() &&
+              new_node->id() != model.synced_node()->id());
 
   // Add another folder, just to make sure folder_ids are incremented correctly.
   ClearCounts();
   model.AddFolder(root, 0, title);
   AssertObserverCount(1, 0, 0, 0, 0);
   observer_details.AssertEquals(root, NULL, 0, -1);
 }
 
 TEST_F(BookmarkModelTest, RemoveURL) {
   const BookmarkNode* root = model.GetBookmarkBarNode();
@@ skipping 147 matching lines @@
 
 // Tests that adding a URL to a folder updates the last modified time.
 TEST_F(BookmarkModelTest, ParentForNewNodes) {
   ASSERT_EQ(model.GetBookmarkBarNode(), model.GetParentForNewNodes());
 
   const string16 title(ASCIIToUTF16("foo"));
   const GURL url("http://foo.com");
 
   model.AddURL(model.other_node(), 0, title, url);
   ASSERT_EQ(model.other_node(), model.GetParentForNewNodes());
+
+  model.AddURL(model.synced_node(), 0, title, url);
+  ASSERT_EQ(model.synced_node(), model.GetParentForNewNodes());
 }
 
 // Make sure recently modified stays in sync when adding a URL.
 TEST_F(BookmarkModelTest, MostRecentlyModifiedFolders) {
   // Add a folder.
   const BookmarkNode* folder = model.AddFolder(model.other_node(), 0,
                                                ASCIIToUTF16("foo"));
   // Add a URL to it.
   model.AddURL(folder, 0, ASCIIToUTF16("blah"), GURL("http://foo.com"));
 
@@ skipping 359 matching lines @@
 
 // Creates a set of nodes in the bookmark bar model, then recreates the
 // bookmark bar model which triggers loading from the db and checks the loaded
 // structure to make sure it is what we first created.
 TEST_F(BookmarkModelTestWithProfile, CreateAndRestore) {
   struct TestData {
     // Structure of the children of the bookmark bar model node.
     const std::string bbn_contents;
     // Structure of the children of the other node.
     const std::string other_contents;
+    // Structure of the children of the synced node.
+    const std::string synced_contents;
   } data[] = {
     // See PopulateNodeFromString for a description of these strings.
     { "", "" },
     { "a", "b" },
     { "a [ b ]", "" },
     { "", "[ b ] a [ c [ d e [ f ] ] ]" },
     { "a [ b ]", "" },
     { "a b c [ d e [ f ] ]", "g h i [ j k [ l ] ]"},
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
     // Recreate the profile. We need to reset with NULL first so that the last
     // HistoryService releases the locks on the files it creates and we can
     // delete them.
     profile_.reset(NULL);
     profile_.reset(new TestingProfile());
     profile_->CreateBookmarkModel(true);
     profile_->CreateHistoryService(true, false);
     BlockTillBookmarkModelLoaded();
 
     TestNode bbn;
     PopulateNodeFromString(data[i].bbn_contents, &bbn);
     PopulateBookmarkNode(&bbn, bb_model_, bb_model_->GetBookmarkBarNode());
 
     TestNode other;
     PopulateNodeFromString(data[i].other_contents, &other);
     PopulateBookmarkNode(&other, bb_model_, bb_model_->other_node());
 
+    TestNode synced;
+    PopulateNodeFromString(data[i].synced_contents, &synced);
+    PopulateBookmarkNode(&synced, bb_model_, bb_model_->synced_node());
+
     profile_->CreateBookmarkModel(false);
     BlockTillBookmarkModelLoaded();
 
     VerifyModelMatchesNode(&bbn, bb_model_->GetBookmarkBarNode());
     VerifyModelMatchesNode(&other, bb_model_->other_node());
+    VerifyModelMatchesNode(&synced, bb_model_->synced_node());
     VerifyNoDuplicateIDs(bb_model_);
   }
 }
 
 // Test class that creates a BookmarkModel with a real history backend.
 class BookmarkModelTestWithProfile2 : public BookmarkModelTestWithProfile {
  public:
   virtual void SetUp() {
     profile_.reset(new TestingProfile());
   }
@@ skipping 49 matching lines @@
     ASSERT_TRUE(child->is_folder());
     ASSERT_EQ(ASCIIToUTF16("OF1"), child->GetTitle());
     ASSERT_EQ(0, child->child_count());
 
     child = parent->GetChild(1);
     ASSERT_EQ(BookmarkNode::URL, child->type());
     ASSERT_EQ(ASCIIToUTF16("About Google"), child->GetTitle());
     ASSERT_TRUE(child->GetURL() ==
                 GURL("http://www.google.com/intl/en/about.html"));
 
+    parent = bb_model_->synced_node();
+    ASSERT_EQ(0, parent->child_count());
+
     ASSERT_TRUE(bb_model_->IsBookmarked(GURL("http://www.google.com")));
   }
 
   void VerifyUniqueIDs() {
     std::set<int64> ids;
     bool has_unique = true;
     VerifyUniqueIDImpl(bb_model_->GetBookmarkBarNode(), &ids, &has_unique);
     VerifyUniqueIDImpl(bb_model_->other_node(), &ids, &has_unique);
     ASSERT_TRUE(has_unique);
   }
@@ skipping 114 matching lines @@
   // Make sure we were notified.
   AssertObserverCount(0, 0, 0, 0, 1);
 
   // Make sure the order matches (remember, 'a' and 'C' are folders and
   // come first).
   EXPECT_EQ(parent->GetChild(0)->GetTitle(), ASCIIToUTF16("a"));
   EXPECT_EQ(parent->GetChild(1)->GetTitle(), ASCIIToUTF16("C"));
   EXPECT_EQ(parent->GetChild(2)->GetTitle(), ASCIIToUTF16("B"));
   EXPECT_EQ(parent->GetChild(3)->GetTitle(), ASCIIToUTF16("d"));
 }