BookmarkModel cleanup. synced_node is now mobile_node and I'm nuking

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/basictypes.h"
 #include "base/command_line.h"
@@ skipping 193 matching lines @@
   const BookmarkNode* bb_node = model_.bookmark_bar_node();
   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());
+  const BookmarkNode* mobile_node = model_.mobile_node();
+  ASSERT_TRUE(mobile_node != NULL);
+  EXPECT_EQ(0, mobile_node->child_count());
+  EXPECT_EQ(BookmarkNode::MOBILE, mobile_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());
+  EXPECT_TRUE(bb_node->id() != mobile_node->id());
+  EXPECT_TRUE(other_node->id() != mobile_node->id());
 }
 
 TEST_F(BookmarkModelTest, AddURL) {
   const BookmarkNode* root = model_.bookmark_bar_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_.ExpectEquals(root, NULL, 0, -1);
 
   ASSERT_EQ(1, root->child_count());
   ASSERT_EQ(title, new_node->GetTitle());
   ASSERT_TRUE(url == new_node->url());
   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());
+              new_node->id() != model_.mobile_node()->id());
 }
 
 TEST_F(BookmarkModelTest, AddURLWithWhitespaceTitle) {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(whitespace_test_cases); ++i) {
     const BookmarkNode* root = model_.bookmark_bar_node();
     const string16 title(ASCIIToUTF16(whitespace_test_cases[i].input_title));
     const GURL url("http://foo.com");
 
     const BookmarkNode* new_node = model_.AddURL(root, i, title, url);
 
     int size = i + 1;
     EXPECT_EQ(size, root->child_count());
     EXPECT_EQ(ASCIIToUTF16(whitespace_test_cases[i].expected_title),
               new_node->GetTitle());
     EXPECT_EQ(BookmarkNode::URL, new_node->type());
   }
 }
 
-TEST_F(BookmarkModelTest, AddURLToSyncedBookmarks) {
-  const BookmarkNode* root = model_.synced_node();
+TEST_F(BookmarkModelTest, AddURLToMobileBookmarks) {
+  const BookmarkNode* root = model_.mobile_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_.ExpectEquals(root, NULL, 0, -1);
 
   ASSERT_EQ(1, root->child_count());
   ASSERT_EQ(title, new_node->GetTitle());
   ASSERT_TRUE(url == new_node->url());
   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());
+              new_node->id() != model_.mobile_node()->id());
 }
 
 TEST_F(BookmarkModelTest, AddFolder) {
   const BookmarkNode* root = model_.bookmark_bar_node();
   const string16 title(ASCIIToUTF16("foo"));
 
   const BookmarkNode* new_node = model_.AddFolder(root, 0, title);
   AssertObserverCount(1, 0, 0, 0, 0);
   observer_details_.ExpectEquals(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_.synced_node()->id());
+              new_node->id() != model_.mobile_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_.ExpectEquals(root, NULL, 0, -1);
 }
 
 TEST_F(BookmarkModelTest, AddFolderWithWhitespaceTitle) {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(whitespace_test_cases); ++i) {
@@ skipping 179 matching lines @@
   ASSERT_EQ(model_.bookmark_bar_node(), 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());
 }
 
 // Tests that adding a URL to a folder updates the last modified time.
-TEST_F(BookmarkModelTest, ParentForNewSyncedNodes) {
+TEST_F(BookmarkModelTest, ParentForNewMobileNodes) {
   ASSERT_EQ(model_.bookmark_bar_node(), model_.GetParentForNewNodes());
 
   const string16 title(ASCIIToUTF16("foo"));
   const GURL url("http://foo.com");
 
-  model_.AddURL(model_.synced_node(), 0, title, url);
-  ASSERT_EQ(model_.synced_node(), model_.GetParentForNewNodes());
+  model_.AddURL(model_.mobile_node(), 0, title, url);
+  ASSERT_EQ(model_.mobile_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 317 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;
+    const std::string mobile_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_->bookmark_bar_node());
 
     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());
+    TestNode mobile;
+    PopulateNodeFromString(data[i].mobile_contents, &mobile);
+    PopulateBookmarkNode(&mobile, bb_model_, bb_model_->mobile_node());
 
     profile_->CreateBookmarkModel(false);
     BlockTillBookmarkModelLoaded();
 
     VerifyModelMatchesNode(&bbn, bb_model_->bookmark_bar_node());
     VerifyModelMatchesNode(&other, bb_model_->other_node());
-    VerifyModelMatchesNode(&synced, bb_model_->synced_node());
+    VerifyModelMatchesNode(&mobile, bb_model_->mobile_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->url() ==
                 GURL("http://www.google.com/intl/en/about.html"));
 
-    parent = bb_model_->synced_node();
+    parent = bb_model_->mobile_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_->bookmark_bar_node(), &ids, &has_unique);
     VerifyUniqueIDImpl(bb_model_->other_node(), &ids, &has_unique);
@@ skipping 117 matching lines @@
   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"));
 }
 
-TEST_F(BookmarkModelTest, NodeVisibility) {
-  EXPECT_TRUE(model_.bookmark_bar_node()->IsVisible());
-  EXPECT_TRUE(model_.other_node()->IsVisible());
-  // Sync node invisible by default
-  EXPECT_FALSE(model_.synced_node()->IsVisible());
-
-  // Arbitrary node should be visible
-  TestNode bbn;
-  PopulateNodeFromString("B", &bbn);
-  const BookmarkNode* parent = model_.bookmark_bar_node();
-  PopulateBookmarkNode(&bbn, &model_, parent);
-  EXPECT_TRUE(parent->GetChild(0)->IsVisible());
-}
-
-TEST_F(BookmarkModelTest, SyncNodeVisibileIfFlagSet) {
-  CommandLine::ForCurrentProcess()->AppendSwitch(
-      switches::kEnableSyncedBookmarksFolder);
-  EXPECT_TRUE(model_.synced_node()->IsVisible());
-}
-
-TEST_F(BookmarkModelTest, SyncNodeVisibileWithChildren) {
-  const BookmarkNode* root = model_.synced_node();
-  const string16 title(ASCIIToUTF16("foo"));
-  const GURL url("http://foo.com");
-
-  model_.AddURL(root, 0, title, url);
-  EXPECT_TRUE(model_.synced_node()->IsVisible());
-}
-
 }  // namespace