Revert "Revert 84829 - Initial implementation of "Synced Bookmarks" folder."

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>
 
+#include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/sync/abstract_profile_sync_service_test.h"
 #include "chrome/browser/sync/engine/syncapi.h"
 #include "chrome/browser/sync/glue/bookmark_change_processor.h"
 #include "chrome/browser/sync/glue/bookmark_model_associator.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/test/sync/engine/test_id_factory.h"
 #include "chrome/test/sync/engine/test_user_share.h"
 #include "chrome/test/testing_profile.h"
 #include "content/browser/browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace browser_sync {
 
 namespace {
@@ skipping 238 matching lines @@
 };
 
 class ProfileSyncServiceBookmarkTest : public testing::Test {
  protected:
   enum LoadOption { LOAD_FROM_STORAGE, DELETE_EXISTING_STORAGE };
   enum SaveOption { SAVE_TO_STORAGE, DONT_SAVE_TO_STORAGE };
 
   ProfileSyncServiceBookmarkTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
         file_thread_(BrowserThread::FILE, &message_loop_),
-        model_(NULL) {
+        model_(NULL),
+        original_command_line_(*CommandLine::ForCurrentProcess()) {
   }
 
   virtual ~ProfileSyncServiceBookmarkTest() {
     StopSync();
     UnloadBookmarkModel();
   }
 
   virtual void SetUp() {
     test_user_share_.SetUp();
+    CommandLine::ForCurrentProcess()->AppendSwitch(
+        switches::kEnableSyncedBookmarksFolder);
   }
 
   virtual void TearDown() {
     test_user_share_.TearDown();
+    *CommandLine::ForCurrentProcess() = original_command_line_;
   }
 
   // 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) {
     bool delete_bookmarks = load == DELETE_EXISTING_STORAGE;
     profile_.CreateBookmarkModel(delete_bookmarks);
     model_ = profile_.GetBookmarkModel();
     // Wait for the bookmarks model to load.
@@ skipping 44 matching lines @@
                                   sync_api::BaseNode* sync_node) {
     return model_associator_->InitSyncNodeFromChromeId(bnode->id(),
                                                        sync_node);
   }
 
   void ExpectSyncerNodeMatching(sync_api::BaseTransaction* trans,
                                 const BookmarkNode* bnode) {
     sync_api::ReadNode gnode(trans);
     ASSERT_TRUE(InitSyncNodeFromChromeNode(bnode, &gnode));
     // Non-root node titles and parents must match.
-    if (bnode != model_->GetBookmarkBarNode() &&
-        bnode != model_->other_node()) {
+    if (!model_->is_permanent_node(bnode)) {
       EXPECT_EQ(bnode->GetTitle(), WideToUTF16Hack(gnode.GetTitle()));
       EXPECT_EQ(
           model_associator_->GetChromeNodeFromSyncId(gnode.GetParentId()),
           bnode->parent());
     }
     EXPECT_EQ(bnode->is_folder(), gnode.GetIsFolder());
     if (bnode->is_url())
       EXPECT_EQ(bnode->GetURL(), gnode.GetURL());
 
     // Check for position matches.
@@ skipping 78 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_->GetBookmarkBarNode()), 0);
     EXPECT_EQ(root->GetIndexOf(model_->other_node()), 1);
+    EXPECT_EQ(root->GetIndexOf(model_->synced_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(test_user_share_.user_share());
     ExpectModelMatch(&trans);
   }
 
+  int64 synced_bookmarks_id() {
+    return
+        model_associator_->GetSyncIdFromChromeId(model_->synced_node()->id());
+  }
+
   int64 other_bookmarks_id() {
     return
         model_associator_->GetSyncIdFromChromeId(model_->other_node()->id());
   }
 
   int64 bookmark_bar_id() {
     return model_associator_->GetSyncIdFromChromeId(
         model_->GetBookmarkBarNode()->id());
   }
 
  private:
   // Used by both |ui_thread_| and |file_thread_|.
   MessageLoop message_loop_;
   BrowserThread ui_thread_;
   // Needed by |model_|.
   BrowserThread file_thread_;
 
   TestingProfile profile_;
   scoped_ptr<TestBookmarkModelAssociator> model_associator_;
 
  protected:
   BookmarkModel* model_;
+  CommandLine original_command_line_;
   TestUserShare test_user_share_;
   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());
 
   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);
+  ExpectModelMatch();
 
   // Test modification.
   model_->SetTitle(url2, ASCIIToUTF16("EasyJet"));
   ExpectModelMatch();
   model_->Move(url1, folder2, 0);
   ExpectModelMatch();
   model_->Move(folder2, model_->GetBookmarkBarNode(), 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_->GetBookmarkBarNode(), 0);
   ExpectModelMatch();
+  model_->SetTitle(synced_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);
+  ExpectModelMatch();
 }
 
 TEST_F(ProfileSyncServiceBookmarkTest, ServerChangeProcessing) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   StartSync();
 
   sync_api::WriteTransaction trans(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);
 
   std::vector<sync_api::SyncManager::ChangeRecord>::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");
+
   // 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);
 
+  ExpectBrowserNodeTitle(u6, u6_old_title);
+
   // Apply the changes.
   mods.ApplyPendingChanges(change_processor_.get());
 
   // Check for successful application.
   for (it = mods.changes().begin(); it != mods.changes().end(); ++it)
     ExpectBrowserNodeMatching(&trans, it->id);
   ExpectModelMatch(&trans);
 
   // Part 3: Test URL deletion.
   FakeServerChange dels(&trans);
   dels.Delete(u2);
   dels.Delete(u3);
+  dels.Delete(u6);
 
   ExpectBrowserNodeKnown(u2);
   ExpectBrowserNodeKnown(u3);
 
   dels.ApplyPendingChanges(change_processor_.get());
 
   ExpectBrowserNodeUnknown(u2);
   ExpectBrowserNodeUnknown(u3);
+  ExpectBrowserNodeUnknown(u6);
   ExpectModelMatch(&trans);
 }
 
 // Tests a specific case in ApplyModelChanges where we move the
 // children out from under a parent, and then delete the parent
 // in the same changelist.  The delete shows up first in the changelist,
 // requiring the children to be moved to a temporary location.
 TEST_F(ProfileSyncServiceBookmarkTest, ServerChangeRequiringFosterParent) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   StartSync();
@@ skipping 266 matching lines @@
 // |   |   |-- f1u2, http://www.f1u2.com/
 // |   |   |-- f1u3, http://www.f1u3.com/
 // |   |   +-- f1u1, http://www.f1u1.com/
 // |   |-- u1, http://www.u1.com/
 // |   +-- f2
 // |       |-- f2u2, http://www.f2u2.com/
 // |       |-- f2u4, http://www.f2u4.com/
 // |       |-- f2u3, http://www.f2u3.com/
 // |       +-- f2u1, http://www.f2u1.com/
 // +-- Other bookmarks
-//     |-- f3
-//     |   |-- f3u4, http://www.f3u4.com/
-//     |   |-- f3u2, http://www.f3u2.com/
-//     |   |-- f3u3, http://www.f3u3.com/
-//     |   +-- f3u1, http://www.f3u1.com/
-//     |-- u4, http://www.u4.com/
-//     |-- u3, http://www.u3.com/
-//     --- 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/
-//
+// |   |-- f3
+// |   |   |-- f3u4, http://www.f3u4.com/
+// |   |   |-- f3u2, http://www.f3u2.com/
+// |   |   |-- f3u3, http://www.f3u3.com/
+// |   |   +-- f3u1, http://www.f3u1.com/
+// |   |-- u4, http://www.u4.com/
+// |   |-- u3, http://www.u3.com/
+// |   --- 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
+//     |-- 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 },
   { L"u1", "http://www.u1.com/" },
   { L"f2", NULL },
 };
 static TestData kF1Children[] = {
   { L"f1u4", "http://www.f1u4.com/" },
   { L"f1u2", "http://www.f1u2.com/" },
   { L"f1u3", "http://www.f1u3.com/" },
@@ skipping 26 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[] = {
+  { 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/" },
+  { L"f6u2", "http://www.f6u2.com/" },
+};
+
 }  // anonymous namespace.
 
 void ProfileSyncServiceBookmarkTestWithData::PopulateFromTestData(
     const BookmarkNode* node, const TestData* data, int size) {
   DCHECK(node);
   DCHECK(data);
   DCHECK(node->is_folder());
   for (int i = 0; i < size; ++i) {
     const TestData& item = data[i];
     if (item.url) {
@@ skipping 47 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));
+
+  ASSERT_GE(synced_bookmarks_node->child_count(), 3);
+  const BookmarkNode* f5_node = synced_bookmarks_node->GetChild(0);
+  PopulateFromTestData(f5_node, kF5Children, arraysize(kF5Children));
+  const BookmarkNode* f6_node = synced_bookmarks_node->GetChild(1);
+  PopulateFromTestData(f6_node, kF6Children, arraysize(kF6Children));
+
   ExpectBookmarkModelMatchesTestData();
 }
 
 void ProfileSyncServiceBookmarkTestWithData::
     ExpectBookmarkModelMatchesTestData() {
   const BookmarkNode* bookmark_bar_node = model_->GetBookmarkBarNode();
   CompareWithTestData(bookmark_bar_node,
                       kBookmarkBarChildren,
                       arraysize(kBookmarkBarChildren));
 
@@ skipping 10 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));
+
+  ASSERT_GE(synced_bookmarks_node->child_count(), 3);
+  const BookmarkNode* f5_node = synced_bookmarks_node->GetChild(0);
+  CompareWithTestData(f5_node, kF5Children, arraysize(kF5Children));
+  const BookmarkNode* f6_node = synced_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();
 
   WriteTestDataToBookmarkModel();
 
@@ skipping 46 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_->GetBookmarkBarNode()->child_count(), 0);
   EXPECT_EQ(model_->other_node()->child_count(), 0);
+  EXPECT_EQ(model_->synced_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