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

chrome/browser/sync/profile_sync_service_bookmark_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.
 
 // TODO(akalin): This file is basically just a unit test for
 // BookmarkChangeProcessor.  Write unit tests for
 // BookmarkModelAssociator separately.
 
 #include <stack>
 #include <vector>
@@ skipping 278 matching lines @@
         model_(NULL) {
   }
 
   virtual ~ProfileSyncServiceBookmarkTest() {
     StopSync();
     UnloadBookmarkModel();
   }
 
   virtual void SetUp() {
     test_user_share_.SetUp();
-    CommandLine::ForCurrentProcess()->AppendSwitch(
-        switches::kEnableSyncedBookmarksFolder);
   }
 
   virtual void TearDown() {
     test_user_share_.TearDown();
   }
 
   // Load (or re-load) the bookmark model.  |load| controls use of the
   // bookmarks file on disk.  |save| controls whether the newly loaded
   // bookmark model will write out a bookmark file as it goes.
   void LoadBookmarkModel(LoadOption load, SaveOption save) {
@@ skipping 147 matching lines @@
     const BookmarkNode* parent =
         model_associator_->GetChromeNodeFromSyncId(parent_sync_id);
     EXPECT_TRUE(parent);
     EXPECT_EQ(node->parent(), parent);
   }
 
   void ExpectModelMatch(sync_api::BaseTransaction* trans) {
     const BookmarkNode* root = model_->root_node();
     EXPECT_EQ(root->GetIndexOf(model_->bookmark_bar_node()), 0);
     EXPECT_EQ(root->GetIndexOf(model_->other_node()), 1);
-    EXPECT_EQ(root->GetIndexOf(model_->synced_node()), 2);
+    EXPECT_EQ(root->GetIndexOf(model_->mobile_node()), 2);
 
     std::stack<int64> stack;
     stack.push(bookmark_bar_id());
     while (!stack.empty()) {
       int64 id = stack.top();
       stack.pop();
       if (!id) continue;
 
       ExpectBrowserNodeMatching(trans, id);
 
       sync_api::ReadNode gnode(trans);
       ASSERT_TRUE(gnode.InitByIdLookup(id));
       stack.push(gnode.GetFirstChildId());
       stack.push(gnode.GetSuccessorId());
     }
   }
 
   void ExpectModelMatch() {
     sync_api::ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ExpectModelMatch(&trans);
   }
 
-  int64 synced_bookmarks_id() {
+  int64 mobile_bookmarks_id() {
     return
-        model_associator_->GetSyncIdFromChromeId(model_->synced_node()->id());
+        model_associator_->GetSyncIdFromChromeId(model_->mobile_node()->id());
   }
 
   int64 other_bookmarks_id() {
     return
         model_associator_->GetSyncIdFromChromeId(model_->other_node()->id());
   }
 
   int64 bookmark_bar_id() {
     return model_associator_->GetSyncIdFromChromeId(
         model_->bookmark_bar_node()->id());
@@ skipping 15 matching lines @@
   scoped_ptr<BookmarkChangeProcessor> change_processor_;
   StrictMock<MockUnrecoverableErrorHandler> mock_unrecoverable_error_handler_;
 };
 
 TEST_F(ProfileSyncServiceBookmarkTest, InitialState) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   StartSync();
 
   EXPECT_TRUE(other_bookmarks_id());
   EXPECT_TRUE(bookmark_bar_id());
-  EXPECT_TRUE(synced_bookmarks_id());
+  EXPECT_TRUE(mobile_bookmarks_id());
 
   ExpectModelMatch();
 }
 
 TEST_F(ProfileSyncServiceBookmarkTest, BookmarkModelOperations) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   StartSync();
 
   // Test addition.
   const BookmarkNode* folder =
       model_->AddFolder(model_->other_node(), 0, ASCIIToUTF16("foobar"));
   ExpectSyncerNodeMatching(folder);
   ExpectModelMatch();
   const BookmarkNode* folder2 =
       model_->AddFolder(folder, 0, ASCIIToUTF16("nested"));
   ExpectSyncerNodeMatching(folder2);
   ExpectModelMatch();
   const BookmarkNode* url1 = model_->AddURL(
       folder, 0, ASCIIToUTF16("Internets #1 Pies Site"),
       GURL("http://www.easypie.com/"));
   ExpectSyncerNodeMatching(url1);
   ExpectModelMatch();
   const BookmarkNode* url2 = model_->AddURL(
       folder, 1, ASCIIToUTF16("Airplanes"), GURL("http://www.easyjet.com/"));
   ExpectSyncerNodeMatching(url2);
   ExpectModelMatch();
   // Test addition.
-  const BookmarkNode* synced_folder =
-      model_->AddFolder(model_->synced_node(), 0, ASCIIToUTF16("pie"));
-  ExpectSyncerNodeMatching(synced_folder);
+  const BookmarkNode* mobile_folder =
+      model_->AddFolder(model_->mobile_node(), 0, ASCIIToUTF16("pie"));
+  ExpectSyncerNodeMatching(mobile_folder);
   ExpectModelMatch();
 
   // Test modification.
   model_->SetTitle(url2, ASCIIToUTF16("EasyJet"));
   ExpectModelMatch();
   model_->Move(url1, folder2, 0);
   ExpectModelMatch();
   model_->Move(folder2, model_->bookmark_bar_node(), 0);
   ExpectModelMatch();
   model_->SetTitle(folder2, ASCIIToUTF16("Not Nested"));
   ExpectModelMatch();
   model_->Move(folder, folder2, 0);
   ExpectModelMatch();
   model_->SetTitle(folder, ASCIIToUTF16("who's nested now?"));
   ExpectModelMatch();
   model_->Copy(url2, model_->bookmark_bar_node(), 0);
   ExpectModelMatch();
-  model_->SetTitle(synced_folder, ASCIIToUTF16("strawberry"));
+  model_->SetTitle(mobile_folder, ASCIIToUTF16("strawberry"));
   ExpectModelMatch();
 
   // Test deletion.
   // Delete a single item.
   model_->Remove(url2->parent(), url2->parent()->GetIndexOf(url2));
   ExpectModelMatch();
   // Delete an item with several children.
   model_->Remove(folder2->parent(),
                  folder2->parent()->GetIndexOf(folder2));
   ExpectModelMatch();
-  model_->Remove(model_->synced_node(), 0);
+  model_->Remove(model_->mobile_node(), 0);
   ExpectModelMatch();
 }
 
 TEST_F(ProfileSyncServiceBookmarkTest, ServerChangeProcessing) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   StartSync();
 
   sync_api::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
 
   FakeServerChange adds(&trans);
   int64 f1 = adds.AddFolder(L"Server Folder B", bookmark_bar_id(), 0);
   int64 f2 = adds.AddFolder(L"Server Folder A", bookmark_bar_id(), f1);
   int64 u1 = adds.AddURL(L"Some old site", "ftp://nifty.andrew.cmu.edu/",
                          bookmark_bar_id(), f2);
   int64 u2 = adds.AddURL(L"Nifty", "ftp://nifty.andrew.cmu.edu/", f1, 0);
   // u3 is a duplicate URL
   int64 u3 = adds.AddURL(L"Nifty2", "ftp://nifty.andrew.cmu.edu/", f1, u2);
   // u4 is a duplicate title, different URL.
   adds.AddURL(L"Some old site", "http://slog.thestranger.com/",
               bookmark_bar_id(), u1);
   // u5 tests an empty-string title.
   std::string javascript_url(
       "javascript:(function(){var w=window.open(" \
       "'about:blank','gnotesWin','location=0,menubar=0," \
       "scrollbars=0,status=0,toolbar=0,width=300," \
       "height=300,resizable');});");
   adds.AddURL(L"", javascript_url, other_bookmarks_id(), 0);
   int64 u6 = adds.AddURL(L"Sync1", "http://www.syncable.edu/",
-                         synced_bookmarks_id(), 0);
+                         mobile_bookmarks_id(), 0);
 
   sync_api::ChangeRecordList::const_iterator it;
   // The bookmark model shouldn't yet have seen any of the nodes of |adds|.
   for (it = adds.changes().begin(); it != adds.changes().end(); ++it)
     ExpectBrowserNodeUnknown(it->id);
 
   adds.ApplyPendingChanges(change_processor_.get());
 
   // Make sure the bookmark model received all of the nodes in |adds|.
   for (it = adds.changes().begin(); it != adds.changes().end(); ++it)
     ExpectBrowserNodeMatching(&trans, it->id);
   ExpectModelMatch(&trans);
 
   // Part two: test modifications.
   FakeServerChange mods(&trans);
   // Mess with u2, and move it into empty folder f2
   // TODO(ncarter): Determine if we allow ModifyURL ops or not.
   /* std::wstring u2_old_url = mods.ModifyURL(u2, L"http://www.google.com"); */
   std::wstring u2_old_title = mods.ModifyTitle(u2, L"The Google");
   int64 u2_old_parent = mods.ModifyPosition(u2, f2, 0);
 
   // Now move f1 after u2.
   std::wstring f1_old_title = mods.ModifyTitle(f1, L"Server Folder C");
   int64 f1_old_parent = mods.ModifyPosition(f1, f2, u2);
 
   // Then add u3 after f1.
   int64 u3_old_parent = mods.ModifyPosition(u3, f2, f1);
 
-  std::wstring u6_old_title = mods.ModifyTitle(u6, L"Synced Folder A");
+  std::wstring u6_old_title = mods.ModifyTitle(u6, L"Mobile Folder A");
 
   // Test that the property changes have not yet taken effect.
   ExpectBrowserNodeTitle(u2, u2_old_title);
   /* ExpectBrowserNodeURL(u2, u2_old_url); */
   ExpectBrowserNodeParent(u2, u2_old_parent);
 
   ExpectBrowserNodeTitle(f1, f1_old_title);
   ExpectBrowserNodeParent(f1, f1_old_parent);
 
   ExpectBrowserNodeParent(u3, u3_old_parent);
@@ skipping 318 matching lines @@
 // |   --- f4
 // |   |   |-- f4u1, http://www.f4u1.com/
 // |   |   |-- f4u2, http://www.f4u2.com/
 // |   |   |-- f4u3, http://www.f4u3.com/
 // |   |   +-- f4u4, http://www.f4u4.com/
 // |   |-- dup
 // |   |   +-- dupu1, http://www.dupu1.com/
 // |   +-- dup
 // |       +-- dupu2, http://www.dupu1.com/
 // |
-// +-- Synced bookmarks
+// +-- Mobile bookmarks
 //     |-- f5
 //     |   |-- f5u1, http://www.f5u1.com/
 //     |-- f6
 //     |   |-- f6u1, http://www.f6u1.com/
 //     |   |-- f6u2, http://www.f6u2.com/
 //     +-- u5, http://www.u5.com/
 
 static TestData kBookmarkBarChildren[] = {
   { L"u2", "http://www.u2.com/" },
   { L"f1", NULL },
@@ skipping 33 matching lines @@
   { L"f4u3", "http://www.f4u3.com/" },
   { L"f4u4", "http://www.f4u4.com/" },
 };
 static TestData kDup1Children[] = {
   { L"dupu1", "http://www.dupu1.com/" },
 };
 static TestData kDup2Children[] = {
   { L"dupu2", "http://www.dupu2.com/" },
 };
 
-static TestData kSyncedBookmarkChildren[] = {
+static TestData kMobileBookmarkChildren[] = {
   { L"f5", NULL },
   { L"f6", NULL },
   { L"u5", "http://www.u5.com/" },
 };
 static TestData kF5Children[] = {
   { L"f5u1", "http://www.f5u1.com/" },
   { L"f5u2", "http://www.f5u2.com/" },
 };
 static TestData kF6Children[] = {
   { L"f6u1", "http://www.f6u1.com/" },
@@ skipping 60 matching lines @@
   ASSERT_GE(other_bookmarks_node->child_count(), 6);
   const BookmarkNode* f3_node = other_bookmarks_node->GetChild(0);
   PopulateFromTestData(f3_node, kF3Children, arraysize(kF3Children));
   const BookmarkNode* f4_node = other_bookmarks_node->GetChild(3);
   PopulateFromTestData(f4_node, kF4Children, arraysize(kF4Children));
   const BookmarkNode* dup_node = other_bookmarks_node->GetChild(4);
   PopulateFromTestData(dup_node, kDup1Children, arraysize(kDup1Children));
   dup_node = other_bookmarks_node->GetChild(5);
   PopulateFromTestData(dup_node, kDup2Children, arraysize(kDup2Children));
 
-  const BookmarkNode* synced_bookmarks_node = model_->synced_node();
-  PopulateFromTestData(synced_bookmarks_node,
-                       kSyncedBookmarkChildren,
-                       arraysize(kSyncedBookmarkChildren));
+  const BookmarkNode* mobile_bookmarks_node = model_->mobile_node();
+  PopulateFromTestData(mobile_bookmarks_node,
+                       kMobileBookmarkChildren,
+                       arraysize(kMobileBookmarkChildren));
 
-  ASSERT_GE(synced_bookmarks_node->child_count(), 3);
-  const BookmarkNode* f5_node = synced_bookmarks_node->GetChild(0);
+  ASSERT_GE(mobile_bookmarks_node->child_count(), 3);
+  const BookmarkNode* f5_node = mobile_bookmarks_node->GetChild(0);
   PopulateFromTestData(f5_node, kF5Children, arraysize(kF5Children));
-  const BookmarkNode* f6_node = synced_bookmarks_node->GetChild(1);
+  const BookmarkNode* f6_node = mobile_bookmarks_node->GetChild(1);
   PopulateFromTestData(f6_node, kF6Children, arraysize(kF6Children));
 
   ExpectBookmarkModelMatchesTestData();
 }
 
 void ProfileSyncServiceBookmarkTestWithData::
     ExpectBookmarkModelMatchesTestData() {
   const BookmarkNode* bookmark_bar_node = model_->bookmark_bar_node();
   CompareWithTestData(bookmark_bar_node,
                       kBookmarkBarChildren,
@@ skipping 13 matching lines @@
   ASSERT_GE(other_bookmarks_node->child_count(), 6);
   const BookmarkNode* f3_node = other_bookmarks_node->GetChild(0);
   CompareWithTestData(f3_node, kF3Children, arraysize(kF3Children));
   const BookmarkNode* f4_node = other_bookmarks_node->GetChild(3);
   CompareWithTestData(f4_node, kF4Children, arraysize(kF4Children));
   const BookmarkNode* dup_node = other_bookmarks_node->GetChild(4);
   CompareWithTestData(dup_node, kDup1Children, arraysize(kDup1Children));
   dup_node = other_bookmarks_node->GetChild(5);
   CompareWithTestData(dup_node, kDup2Children, arraysize(kDup2Children));
 
-  const BookmarkNode* synced_bookmarks_node = model_->synced_node();
-  CompareWithTestData(synced_bookmarks_node,
-                      kSyncedBookmarkChildren,
-                      arraysize(kSyncedBookmarkChildren));
+  const BookmarkNode* mobile_bookmarks_node = model_->mobile_node();
+  CompareWithTestData(mobile_bookmarks_node,
+                      kMobileBookmarkChildren,
+                      arraysize(kMobileBookmarkChildren));
 
-  ASSERT_GE(synced_bookmarks_node->child_count(), 3);
-  const BookmarkNode* f5_node = synced_bookmarks_node->GetChild(0);
+  ASSERT_GE(mobile_bookmarks_node->child_count(), 3);
+  const BookmarkNode* f5_node = mobile_bookmarks_node->GetChild(0);
   CompareWithTestData(f5_node, kF5Children, arraysize(kF5Children));
-  const BookmarkNode* f6_node = synced_bookmarks_node->GetChild(1);
+  const BookmarkNode* f6_node = mobile_bookmarks_node->GetChild(1);
   CompareWithTestData(f6_node, kF6Children, arraysize(kF6Children));
 
 }
 
 // Tests persistence of the profile sync service by unloading the
 // database and then reloading it from disk.
 TEST_F(ProfileSyncServiceBookmarkTestWithData, Persistence) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, SAVE_TO_STORAGE);
   StartSync();
 
@@ skipping 48 matching lines @@
   ExpectModelMatch();
 
   // Force the databse to unload and write itself to disk.
   StopSync();
 
   // Blow away the bookmark model -- it should be empty afterwards.
   UnloadBookmarkModel();
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   EXPECT_EQ(model_->bookmark_bar_node()->child_count(), 0);
   EXPECT_EQ(model_->other_node()->child_count(), 0);
-  EXPECT_EQ(model_->synced_node()->child_count(), 0);
+  EXPECT_EQ(model_->mobile_node()->child_count(), 0);
 
   // Now restart the sync service.  Starting it should populate the bookmark
   // model -- test for consistency.
   StartSync();
   ExpectBookmarkModelMatchesTestData();
   ExpectModelMatch();
 }
 
 // Tests the merge cases when both the models are expected to be identical
 // after the merge.
@@ skipping 179 matching lines @@
   // Make sure we're back in sync.  In real life, the user would need
   // to reauthenticate before this happens, but in the test, authentication
   // is sidestepped.
   ExpectBookmarkModelMatchesTestData();
   ExpectModelMatch();
 }
 
 }  // namespace
 
 }  // namespace browser_sync