Initial implementation of "Synced Bookmarks" folder.

chrome/browser/ui/gtk/bookmarks/bookmark_editor_gtk_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 <gtk/gtk.h>
 
 #include <string>
 
+#include "base/command_line.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/ui/gtk/bookmarks/bookmark_editor_gtk.h"
 #include "chrome/browser/ui/gtk/bookmarks/bookmark_tree_model.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/test/testing_profile.h"
 #include "content/browser/browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 using base::TimeDelta;
 using bookmark_utils::GetTitleFromTreeIter;
 
 // Base class for bookmark editor tests. This class is a copy from
 // bookmark_editor_view_unittest.cc, and all the tests in this file are
 // GTK-ifications of the corresponding views tests. Testing here is really
 // important because on Linux, we make round trip copies from chrome's
 // BookmarkModel class to GTK's native GtkTreeStore.
 class BookmarkEditorGtkTest : public testing::Test {
  public:
   BookmarkEditorGtkTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
         file_thread_(BrowserThread::FILE, &message_loop_),
         model_(NULL) {
   }
 
   virtual void SetUp() {
+    CommandLine::ForCurrentProcess()->AppendSwitch(
+        switches::kEnableSyncedBookmarksFolder);
     profile_.reset(new TestingProfile());
     profile_->CreateBookmarkModel(true);
     profile_->BlockUntilBookmarkModelLoaded();
 
     model_ = profile_->GetBookmarkModel();
 
     AddTestData();
   }
 
   virtual void TearDown() {
@@ skipping 18 matching lines @@
   //   a
   //   F1
   //    f1a
   //    F11
   //     f11a
   //   F2
   // other node
   //   oa
   //   OF1
   //     of1a
+  // synced node
+  //   sa
   void AddTestData() {
     std::string test_base = base_path();
 
     model_->AddURL(model_->GetBookmarkBarNode(), 0, ASCIIToUTF16("a"),
                    GURL(test_base + "a"));
     const BookmarkNode* f1 =
         model_->AddFolder(model_->GetBookmarkBarNode(), 1, ASCIIToUTF16("F1"));
     model_->AddURL(f1, 0, ASCIIToUTF16("f1a"), GURL(test_base + "f1a"));
     const BookmarkNode* f11 = model_->AddFolder(f1, 1, ASCIIToUTF16("F11"));
     model_->AddURL(f11, 0, ASCIIToUTF16("f11a"), GURL(test_base + "f11a"));
     model_->AddFolder(model_->GetBookmarkBarNode(), 2, ASCIIToUTF16("F2"));
 
     // Children of the other node.
     model_->AddURL(model_->other_node(), 0, ASCIIToUTF16("oa"),
                    GURL(test_base + "oa"));
     const BookmarkNode* of1 =
         model_->AddFolder(model_->other_node(), 1, ASCIIToUTF16("OF1"));
     model_->AddURL(of1, 0, ASCIIToUTF16("of1a"), GURL(test_base + "of1a"));
+
+    // Children of the synced node.
+    model_->AddURL(model_->synced_node(), 0, ASCIIToUTF16("sa"),
+                   GURL(test_base + "sa"));
   }
 };
 
 // Makes sure the tree model matches that of the bookmark bar model.
 TEST_F(BookmarkEditorGtkTest, ModelsMatch) {
   BookmarkEditorGtk editor(NULL, profile_.get(), NULL,
                            BookmarkEditor::EditDetails(),
                            BookmarkEditor::SHOW_TREE);
 
   // The root should have two children, one for the bookmark bar node,
   // the other for the 'other bookmarks' folder.
   GtkTreeModel* store = GTK_TREE_MODEL(editor.tree_store_);
   GtkTreeIter toplevel;
   ASSERT_TRUE(gtk_tree_model_get_iter_first(store, &toplevel));
   GtkTreeIter bookmark_bar_node = toplevel;
   ASSERT_TRUE(gtk_tree_model_iter_next(store, &toplevel));
   GtkTreeIter other_node = toplevel;
+  ASSERT_TRUE(gtk_tree_model_iter_next(store, &toplevel));
+  GtkTreeIter synced_node = toplevel;
   ASSERT_FALSE(gtk_tree_model_iter_next(store, &toplevel));
 
   // The bookmark bar should have 2 nodes: folder F1 and F2.
   GtkTreeIter f1_iter;
   GtkTreeIter child;
   ASSERT_EQ(2, gtk_tree_model_iter_n_children(store, &bookmark_bar_node));
   ASSERT_TRUE(gtk_tree_model_iter_children(store, &child, &bookmark_bar_node));
   f1_iter = child;
   ASSERT_EQ("F1", UTF16ToUTF8(GetTitleFromTreeIter(store, &child)));
   ASSERT_TRUE(gtk_tree_model_iter_next(store, &child));
   ASSERT_EQ("F2", UTF16ToUTF8(GetTitleFromTreeIter(store, &child)));
   ASSERT_FALSE(gtk_tree_model_iter_next(store, &child));
 
   // F1 should have one child, F11
   ASSERT_EQ(1, gtk_tree_model_iter_n_children(store, &f1_iter));
   ASSERT_TRUE(gtk_tree_model_iter_children(store, &child, &f1_iter));
   ASSERT_EQ("F11", UTF16ToUTF8(GetTitleFromTreeIter(store, &child)));
   ASSERT_FALSE(gtk_tree_model_iter_next(store, &child));
 
   // Other node should have one child (OF1).
   ASSERT_EQ(1, gtk_tree_model_iter_n_children(store, &other_node));
   ASSERT_TRUE(gtk_tree_model_iter_children(store, &child, &other_node));
   ASSERT_EQ("OF1", UTF16ToUTF8(GetTitleFromTreeIter(store, &child)));
   ASSERT_FALSE(gtk_tree_model_iter_next(store, &child));
+
+  // Synced node should have one child (sa).
+  ASSERT_EQ(0, gtk_tree_model_iter_n_children(store, &synced_node));
 }
 
 // Changes the title and makes sure parent/visual order doesn't change.
 TEST_F(BookmarkEditorGtkTest, EditTitleKeepsPosition) {
   BookmarkEditorGtk editor(NULL, profile_.get(), NULL,
                            BookmarkEditor::EditDetails(GetNode("a")),
                            BookmarkEditor::SHOW_TREE);
   gtk_entry_set_text(GTK_ENTRY(editor.name_entry_), "new_a");
 
   GtkTreeIter bookmark_bar_node;
@@ skipping 173 matching lines @@
   gtk_entry_set_text(GTK_ENTRY(editor.name_entry_), "new_a");
 
   editor.ApplyEdits();
 
   const BookmarkNode* other_node = profile_->GetBookmarkModel()->other_node();
   ASSERT_EQ(2, other_node->child_count());
 
   const BookmarkNode* new_node = other_node->GetChild(0);
   EXPECT_EQ(ASCIIToUTF16("new_a"), new_node->GetTitle());
 }