Linux bookmark manager:

- Add more dragging.
- Make right pane updating less clobbery.

Review URL: http://codereview.chromium.org/122005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@18136 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 278 insertions, 91 deletions

diff --git a/chrome/browser/gtk/bookmark_manager_gtk.cc b/chrome/browser/gtk/bookmark_manager_gtk.cc
index 3618e77..a591cf2 100644
--- a/chrome/browser/gtk/bookmark_manager_gtk.cc
+++ b/chrome/browser/gtk/bookmark_manager_gtk.cc
@@ -72,21 +72,106 @@ void BookmarkManagerGtk::Show(Profile* profile) {
 }
 
 void BookmarkManagerGtk::BookmarkManagerGtk::Loaded(BookmarkModel* model) {
-  SuppressUpdatesToRightStore();
   BuildLeftStore();
-  AllowUpdatesToRightStore();
+  BuildRightStore();
+  g_signal_connect(left_selection(), "changed",
+                   G_CALLBACK(OnLeftSelectionChanged), this);
 }
 
 void BookmarkManagerGtk::BookmarkModelBeingDeleted(BookmarkModel* model) {
   gtk_widget_destroy(window_);
 }
 
+void BookmarkManagerGtk::BookmarkNodeMoved(BookmarkModel* model,
+                                           BookmarkNode* old_parent,
+                                           int old_index,
+                                           BookmarkNode* new_parent,
+                                           int new_index) {
+  BookmarkNodeRemoved(model, old_parent, old_index,
+                      new_parent->GetChild(new_index));
+  BookmarkNodeAdded(model, new_parent, new_index);
+}
+
+void BookmarkManagerGtk::BookmarkNodeAdded(BookmarkModel* model,
+                                           BookmarkNode* parent,
+                                           int index) {
+  BookmarkNode* node = parent->GetChild(index);
+  // Update left store.
+  if (node->is_folder()) {
+    GtkTreeIter iter;
+    gtk_tree_model_get_iter_first(GTK_TREE_MODEL(left_store_), &iter);
+
+    if (RecursiveFind(GTK_TREE_MODEL(left_store_), &iter, parent->id()))
+      bookmark_utils::AddToTreeStoreAt(node, 0, left_store_, NULL, &iter);
+  }
+
+  // Update right store.
+  if (parent->id() == GetFolder()->id()) {
+    GtkTreeIter iter;
+    gtk_tree_model_get_iter_first(GTK_TREE_MODEL(right_store_), &iter);
+
+    if (RecursiveFind(GTK_TREE_MODEL(right_store_), &iter,
+        parent->GetChild(index - 1)->id())) {
+      AppendNodeToRightStore(node, &iter);
+    }
+  }
+}
+
+void BookmarkManagerGtk::BookmarkNodeRemoved(BookmarkModel* model,
+                                             BookmarkNode* parent,
+                                             int index) {
+  NOTREACHED();
+}
+
+void BookmarkManagerGtk::BookmarkNodeRemoved(BookmarkModel* model,
+                                             BookmarkNode* parent,
+                                             int old_index,
+                                             BookmarkNode* node) {
+  if (node->is_folder()) {
+    GtkTreeIter iter;
+    gtk_tree_model_get_iter_first(GTK_TREE_MODEL(left_store_), &iter);
+
+    if (RecursiveFind(GTK_TREE_MODEL(left_store_), &iter, node->id())) {
+      // If we are deleting the currently selected folder, set the selection to
+      // its parent.
+      if (gtk_tree_selection_iter_is_selected(left_selection(), &iter)) {
+        GtkTreeIter parent;
+        gtk_tree_model_iter_parent(GTK_TREE_MODEL(left_store_), &parent, &iter);
+        gtk_tree_selection_select_iter(left_selection(), &parent);
+      }
+
+      gtk_tree_store_remove(left_store_, &iter);
+    }
+  }
+
+  GtkTreeIter iter;
+  gtk_tree_model_get_iter_first(GTK_TREE_MODEL(right_store_), &iter);
+
+  if (RecursiveFind(GTK_TREE_MODEL(right_store_), &iter, node->id()))
+    gtk_list_store_remove(right_store_, &iter);
+}
+
+void BookmarkManagerGtk::BookmarkNodeChanged(BookmarkModel* model,
+                                             BookmarkNode* node) {
+  // TODO(estade): implement.
+}
+
+void BookmarkManagerGtk::BookmarkNodeChildrenReordered(BookmarkModel* model,
+                                                       BookmarkNode* node) {
+  if (node->id() == GetFolder()->id())
+    BuildRightStore();
+}
+
+void BookmarkManagerGtk::BookmarkNodeFavIconLoaded(BookmarkModel* model,
+                                                   BookmarkNode* node) {
+  // TODO(estade): implement.
+}
+
 // BookmarkManagerGtk, private -------------------------------------------------
 
 BookmarkManagerGtk::BookmarkManagerGtk(Profile* profile)
     : profile_(profile),
-      model_(profile->GetBookmarkModel()),
-      update_suppressions_(0) {
+      model_(profile->GetBookmarkModel()) {
   InitWidgets();
   g_signal_connect(window_, "destroy",
                    G_CALLBACK(OnWindowDestroy), this);
@@ -173,6 +258,17 @@ GtkWidget* BookmarkManagerGtk::MakeLeftPane() {
   gtk_tree_view_append_column(GTK_TREE_VIEW(left_tree_view_), icon_column);
   gtk_tree_view_append_column(GTK_TREE_VIEW(left_tree_view_), name_column);
 
+  // The left side is only a drag destination (not a source).
+  gtk_drag_dest_set(left_tree_view_, GTK_DEST_DEFAULT_DROP,
+                    bookmark_utils::kTargetTable,
+                    bookmark_utils::kTargetTableSize,
+                    GDK_ACTION_MOVE);
+
+  g_signal_connect(left_tree_view_, "drag-data-received",
+                   G_CALLBACK(&OnLeftTreeViewDragReceived), this);
+  g_signal_connect(left_tree_view_, "drag-motion",
+                   G_CALLBACK(&OnLeftTreeViewDragMotion), this);
+
   GtkWidget* scrolled = gtk_scrolled_window_new(NULL, NULL);
   gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
@@ -189,6 +285,8 @@ GtkWidget* BookmarkManagerGtk::MakeRightPane() {
                                     G_TYPE_STRING, G_TYPE_INT);
 
   GtkTreeViewColumn* title_column = gtk_tree_view_column_new();
+  gtk_tree_view_column_set_title(title_column,
+      l10n_util::GetStringUTF8(IDS_BOOKMARK_TABLE_TITLE).c_str());
   GtkCellRenderer* image_renderer = gtk_cell_renderer_pixbuf_new();
   gtk_tree_view_column_pack_start(title_column, image_renderer, FALSE);
   gtk_tree_view_column_add_attribute(title_column, image_renderer,
@@ -206,8 +304,6 @@ GtkWidget* BookmarkManagerGtk::MakeRightPane() {
   g_object_unref(right_store_);
   gtk_tree_view_append_column(GTK_TREE_VIEW(right_tree_view_), title_column);
   gtk_tree_view_append_column(GTK_TREE_VIEW(right_tree_view_), url_column);
-  g_signal_connect(left_selection(), "changed",
-                   G_CALLBACK(OnLeftSelectionChanged), this);
   g_signal_connect(right_selection(), "changed",
                    G_CALLBACK(OnRightSelectionChanged), this);
 
@@ -221,16 +317,14 @@ GtkWidget* BookmarkManagerGtk::MakeRightPane() {
                                        bookmark_utils::kTargetTableSize,
                                        GDK_ACTION_MOVE);
   g_signal_connect(right_tree_view_, "drag-data-get",
-                   G_CALLBACK(&OnTreeViewDragGet), this);
+                   G_CALLBACK(&OnRightTreeViewDragGet), this);
   g_signal_connect(right_tree_view_, "drag-data-received",
-                   G_CALLBACK(&OnTreeViewDragReceived), this);
+                   G_CALLBACK(&OnRightTreeViewDragReceived), this);
   g_signal_connect(right_tree_view_, "drag-motion",
-                   G_CALLBACK(&OnTreeViewDragMotion), this);
+                   G_CALLBACK(&OnRightTreeViewDragMotion), this);
   // Connect after so we can overwrite the drag icon.
   g_signal_connect_after(right_tree_view_, "drag-begin",
-                         G_CALLBACK(&OnTreeViewDragBegin), this);
-  g_signal_connect(right_tree_view_, "drag-end",
-                   G_CALLBACK(&OnTreeViewDragEnd), this);
+                         G_CALLBACK(&OnRightTreeViewDragBegin), this);
 
   GtkWidget* scrolled = gtk_scrolled_window_new(NULL, NULL);
   gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
@@ -252,9 +346,6 @@ void BookmarkManagerGtk::BuildLeftStore() {
 }
 
 void BookmarkManagerGtk::BuildRightStore() {
-  if (update_suppressions_ > 0)
-    return;
-
   BookmarkNode* node = GetFolder();
   // TODO(estade): eventually we may hit a fake node here (recently bookmarked
   // or search), but until then we require that node != NULL.
@@ -304,7 +395,7 @@ std::vector<BookmarkNode*> BookmarkManagerGtk::GetRightSelection() {
 }
 
 void BookmarkManagerGtk::AppendNodeToRightStore(BookmarkNode* node,
-                                                         GtkTreeIter* iter) {
+                                                GtkTreeIter* iter) {
   GdkPixbuf* pixbuf = bookmark_utils::GetPixbufForNode(node, model_);
   gtk_list_store_append(right_store_, iter);
   gtk_list_store_set(right_store_, iter,
@@ -315,16 +406,37 @@ void BookmarkManagerGtk::AppendNodeToRightStore(BookmarkNode* node,
   g_object_unref(pixbuf);
 }
 
-void BookmarkManagerGtk::SuppressUpdatesToRightStore() {
-  update_suppressions_++;
-}
+bool BookmarkManagerGtk::RecursiveFind(GtkTreeModel* model, GtkTreeIter* iter,
+                                       int target) {
+  GValue value = { 0, };
+  bool left = model == GTK_TREE_MODEL(left_store_);
+  if (left)
+    gtk_tree_model_get_value(model, iter, bookmark_utils::ITEM_ID, &value);
+  else
+    gtk_tree_model_get_value(model, iter, RIGHT_PANE_ID, &value);
+  int id = g_value_get_int(&value);
+  g_value_unset(&value);
 
-void BookmarkManagerGtk::AllowUpdatesToRightStore() {
-  update_suppressions_--;
-  DCHECK_GE(update_suppressions_, 0);
+  if (id == target) {
+    return true;
+  }
 
-  if (update_suppressions_ <= 0)
-    BuildRightStore();
+  GtkTreeIter child;
+  // Check the first child.
+  if (gtk_tree_model_iter_children(model, &child, iter)) {
+    if (RecursiveFind(model, &child, target)) {
+      *iter = child;
+      return true;
+    }
+  }
+
+  // Check siblings.
+  while (gtk_tree_model_iter_next(model, iter)) {
+    if (RecursiveFind(model, iter, target))
+      return true;
+  }
+
+  return false;
 }
 
 // static
@@ -348,8 +460,76 @@ void BookmarkManagerGtk::OnRightSelectionChanged(GtkTreeSelection* selection,
       bookmark_manager->GetRightSelection());
 }
 
+// statuc
+void BookmarkManagerGtk::OnLeftTreeViewDragReceived(
+    GtkWidget* tree_view, GdkDragContext* context, gint x, gint y,
+    GtkSelectionData* selection_data, guint target_type, guint time,
+    BookmarkManagerGtk* bm) {
+  gboolean dnd_success = FALSE;
+  gboolean delete_selection_data = FALSE;
+
+  std::vector<BookmarkNode*> nodes =
+      bookmark_utils::GetNodesFromSelection(context, selection_data,
+                                            target_type,
+                                            bm->profile_,
+                                            &delete_selection_data,
+                                            &dnd_success);
+
+  if (nodes.empty()) {
+    gtk_drag_finish(context, FALSE, delete_selection_data, time);
+    return;
+  }
+
+  GtkTreePath* path;
+  GtkTreeViewDropPosition pos;
+  gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y,
+                                    &path, &pos);
+  if (!path) {
+    gtk_drag_finish(context, FALSE, delete_selection_data, time);
+    return;
+  }
+
+  GtkTreeIter iter;
+  gtk_tree_model_get_iter(GTK_TREE_MODEL(bm->left_store_), &iter, path);
+  BookmarkNode* folder = bm->GetNodeAt(GTK_TREE_MODEL(bm->left_store_), &iter);
+  for (std::vector<BookmarkNode*>::iterator it = nodes.begin();
+       it != nodes.end(); ++it) {
+    // Don't try to drop a node into one of its descendants.
+    if (!folder->HasAncestor(*it))
+      bm->model_->Move(*it, folder, 0);
+  }
+
+  gtk_tree_path_free(path);
+  gtk_drag_finish(context, dnd_success, delete_selection_data, time);
+}
+
 // static
-void BookmarkManagerGtk::OnTreeViewDragGet(
+gboolean BookmarkManagerGtk::OnLeftTreeViewDragMotion(GtkWidget* tree_view,
+    GdkDragContext* context, gint x, gint y, guint time,
+    BookmarkManagerGtk* bm) {
+  GtkTreePath* path;
+  GtkTreeViewDropPosition pos;
+  gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y,
+                                    &path, &pos);
+
+  if (path) {
+    // Only allow INTO.
+    if (pos == GTK_TREE_VIEW_DROP_BEFORE)
+      pos = GTK_TREE_VIEW_DROP_INTO_OR_BEFORE;
+    else if (pos == GTK_TREE_VIEW_DROP_AFTER)
+      pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
+    gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(tree_view), path, pos);
+  } else {
+    return FALSE;
+  }
+
+  gdk_drag_status(context, GDK_ACTION_MOVE, time);
+  gtk_tree_path_free(path);
+  return TRUE;
+}
+
+// static
+void BookmarkManagerGtk::OnRightTreeViewDragGet(
     GtkWidget* tree_view,
     GdkDragContext* context, GtkSelectionData* selection_data,
     guint target_type, guint time, BookmarkManagerGtk* bookmark_manager) {
@@ -360,7 +540,7 @@ void BookmarkManagerGtk::OnTreeViewDragGet(
 }
 
 // static
-void BookmarkManagerGtk::OnTreeViewDragReceived(
+void BookmarkManagerGtk::OnRightTreeViewDragReceived(
     GtkWidget* tree_view, GdkDragContext* context, gint x, gint y,
     GtkSelectionData* selection_data, guint target_type, guint time,
     BookmarkManagerGtk* bm) {
@@ -379,8 +559,6 @@ void BookmarkManagerGtk::OnTreeViewDragReceived(
     return;
   }
 
-  // TODO(estade): Support drops on the left side tree view.
-  DCHECK_EQ(tree_view, bm->right_tree_view_);
   GtkTreePath* path;
   GtkTreeViewDropPosition pos;
   gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y,
@@ -421,40 +599,27 @@ void BookmarkManagerGtk::OnTreeViewDragReceived(
         gtk_tree_path_get_indices(path)[gtk_tree_path_get_depth(path) - 1];
   }
 
-  bm->SuppressUpdatesToRightStore();
   for (std::vector<BookmarkNode*>::iterator it = nodes.begin();
        it != nodes.end(); ++it) {
     // Don't try to drop a node into one of its descendants.
     if (!parent->HasAncestor(*it))
       bm->model_->Move(*it, parent, idx++);
   }
-  bm->AllowUpdatesToRightStore();
 
   gtk_tree_path_free(path);
   gtk_drag_finish(context, dnd_success, delete_selection_data, time);
 }
 
 // static
-void BookmarkManagerGtk::OnTreeViewDragBegin(
+void BookmarkManagerGtk::OnRightTreeViewDragBegin(
     GtkWidget* tree_view,
     GdkDragContext* drag_context,
     BookmarkManagerGtk* bookmark_manager) {
   gtk_drag_set_icon_stock(drag_context, GTK_STOCK_DND, 0, 0);
-  // Balanced in OnTreeViewDragEnd().
-  bookmark_manager->SuppressUpdatesToRightStore();
-}
-
-// static
-void BookmarkManagerGtk::OnTreeViewDragEnd(
-    GtkWidget* tree_view,
-    GdkDragContext* drag_context,
-    BookmarkManagerGtk* bookmark_manager) {
-  // Balanced in OnTreeViewDragBegin().
-  bookmark_manager->AllowUpdatesToRightStore();
 }
 
 // static
-gboolean BookmarkManagerGtk::OnTreeViewDragMotion(
+gboolean BookmarkManagerGtk::OnRightTreeViewDragMotion(
     GtkWidget* tree_view, GdkDragContext* context, gint x, gint y, guint time,
     BookmarkManagerGtk* bm) {
   GtkTreePath* path;
diff --git a/chrome/browser/gtk/bookmark_manager_gtk.h b/chrome/browser/gtk/bookmark_manager_gtk.h
index dd47091..3352a25 100644
--- a/chrome/browser/gtk/bookmark_manager_gtk.h
+++ b/chrome/browser/gtk/bookmark_manager_gtk.h
@@ -29,28 +29,27 @@ class BookmarkManagerGtk : public BookmarkModelObserver {
   // BookmarkModelObserver implementation.
   virtual void Loaded(BookmarkModel* model);
   virtual void BookmarkModelBeingDeleted(BookmarkModel* model);
-  // TODO(estade): Implement these.
   virtual void BookmarkNodeMoved(BookmarkModel* model,
                                  BookmarkNode* old_parent,
                                  int old_index,
                                  BookmarkNode* new_parent,
-                                 int new_index) {}
+                                 int new_index);
   virtual void BookmarkNodeAdded(BookmarkModel* model,
                                  BookmarkNode* parent,
-                                 int index) {}
+                                 int index);
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
                                    BookmarkNode* parent,
-                                   int index) {}
+                                   int index);
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
                                    BookmarkNode* parent,
                                    int old_index,
-                                   BookmarkNode* node) {}
+                                   BookmarkNode* node);
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node) {}
+                                   BookmarkNode* node);
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node) {}
+                                             BookmarkNode* node);
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node) {}
+                                         BookmarkNode* node);
 
  private:
   explicit BookmarkManagerGtk(Profile* profile);
@@ -64,7 +63,7 @@ class BookmarkManagerGtk : public BookmarkModelObserver {
   // This one should only be called once (when the bookmark model is loaded).
   void BuildLeftStore();
   // This one clears the old right pane and refills it with the contents of
-  // whatever folder is selected on the left.
+  // whatever folder is selected on the left. It can be called multiple times.
   void BuildRightStore();
 
   // Get the node from |model| at |iter|.
@@ -93,31 +92,41 @@ class BookmarkManagerGtk : public BookmarkModelObserver {
   void SuppressUpdatesToRightStore();
   void AllowUpdatesToRightStore();
 
+  // Tries to find the node with id |target_id|. If found, returns true and set
+  // |iter| to point to the entry.
+  bool RecursiveFind(GtkTreeModel* model, GtkTreeIter* iter, int target_id);
+
   static void OnLeftSelectionChanged(GtkTreeSelection* selection,
                                      BookmarkManagerGtk* bookmark_manager);
 
   static void OnRightSelectionChanged(GtkTreeSelection* selection,
                                       BookmarkManagerGtk* bookmark_manager);
 
-  static void OnTreeViewDragGet(GtkWidget* tree_view, GdkDragContext* context,
+  static void OnLeftTreeViewDragReceived(
+      GtkWidget* tree_view, GdkDragContext* context, gint x, gint y,
+      GtkSelectionData* selection_data, guint target_type, guint time,
+      BookmarkManagerGtk* bookmark_manager);
+
+  static gboolean OnLeftTreeViewDragMotion(GtkWidget* tree_view,
+      GdkDragContext* context, gint x, gint y, guint time,
+      BookmarkManagerGtk* bookmark_manager);
+
+
+  static void OnRightTreeViewDragGet(GtkWidget* tree_view, GdkDragContext* context,
                                 GtkSelectionData* selection_data,
                                 guint target_type, guint time,
                                 BookmarkManagerGtk* bookmark_manager);
 
-  static void OnTreeViewDragReceived(
+  static void OnRightTreeViewDragReceived(
       GtkWidget* tree_view, GdkDragContext* context, gint x, gint y,
       GtkSelectionData* selection_data, guint target_type, guint time,
       BookmarkManagerGtk* bookmark_manager);
 
-  static void OnTreeViewDragBegin(GtkWidget* tree_view,
+  static void OnRightTreeViewDragBegin(GtkWidget* tree_view,
                                   GdkDragContext* drag_context,
                                   BookmarkManagerGtk* bookmark_manager);
 
-  static void OnTreeViewDragEnd(GtkWidget* tree_view,
-                                GdkDragContext* drag_context,
-                                BookmarkManagerGtk* bookmark_manager);
-
-  static gboolean OnTreeViewDragMotion(GtkWidget* tree_view,
+  static gboolean OnRightTreeViewDragMotion(GtkWidget* tree_view,
       GdkDragContext* context, gint x, gint y, guint time,
       BookmarkManagerGtk* bookmark_manager);
 
diff --git a/chrome/browser/gtk/bookmark_tree_model.cc b/chrome/browser/gtk/bookmark_tree_model.cc
index 1b5f4de..14f7471 100644
--- a/chrome/browser/gtk/bookmark_tree_model.cc
+++ b/chrome/browser/gtk/bookmark_tree_model.cc
@@ -13,35 +13,17 @@
 
 namespace {
 
-// Helper function for BuildTreeStoreFrom() which recursively inserts data from
-// a BookmarkNode tree into a GtkTreeStore.
-void RecursiveInsert(BookmarkNode* node, int selected_id,
-                     GtkTreeStore* store, GtkTreeIter* selected_iter,
-                     GtkTreeIter* parent) {
-  GtkTreeIter iter;
-
-  for (int i = 0; i < node->GetChildCount(); ++i) {
-    BookmarkNode* child = node->GetChild(i);
-    if (child->is_folder()) {
-      gtk_tree_store_append(store, &iter, parent);
-      // TODO(estade): we should show the folder open when it's expanded.
-      gtk_tree_store_set(store, &iter,
-                         bookmark_utils::FOLDER_ICON,
-                         bookmark_utils::GetFolderIcon(),
-                         bookmark_utils::FOLDER_NAME,
-                         WideToUTF8(child->GetTitle()).c_str(),
-                         bookmark_utils::ITEM_ID, child->id(),
-                         -1);
-      if (selected_id && child->id() == selected_id) {
-        // Save the iterator. Since we're using a GtkTreeStore, we're
-        // guaranteed that the iterator will remain valid as long as the above
-        // appended item exists.
-        *selected_iter = iter;
-      }
-
-      RecursiveInsert(child, selected_id, store, selected_iter, &iter);
-    }
-  }
+void AddSingleNodeToTreeStore(GtkTreeStore* store, BookmarkNode* node,
+                              GtkTreeIter *iter, GtkTreeIter* parent) {
+  gtk_tree_store_append(store, iter, parent);
+  // TODO(estade): we should show the folder open icon when it's expanded.
+  gtk_tree_store_set(store, iter,
+                     bookmark_utils::FOLDER_ICON,
+                     bookmark_utils::GetFolderIcon(),
+                     bookmark_utils::FOLDER_NAME,
+                     WideToUTF8(node->GetTitle()).c_str(),
+                     bookmark_utils::ITEM_ID, node->id(),
+                     -1);
 }
 
 // Helper function for CommitTreeStoreDifferencesBetween() which recursively
@@ -97,7 +79,32 @@ GtkTreeStore* MakeFolderTreeStore() {
 
 void AddToTreeStore(BookmarkModel* model, int selected_id,
                     GtkTreeStore* store, GtkTreeIter* selected_iter) {
-  RecursiveInsert(model->root_node(), selected_id, store, selected_iter, NULL);
+  BookmarkNode* root_node = model->root_node();
+  for (int i = 0; i < root_node->GetChildCount(); ++i) {
+    AddToTreeStoreAt(root_node->GetChild(i), selected_id, store,
+                     selected_iter, NULL);
+  }
+}
+
+void AddToTreeStoreAt(BookmarkNode* node, int selected_id,
+                      GtkTreeStore* store, GtkTreeIter* selected_iter,
+                      GtkTreeIter* parent) {
+  if (!node->is_folder())
+    return;
+
+  GtkTreeIter iter;
+  AddSingleNodeToTreeStore(store, node, &iter, parent);
+  if (selected_iter && node->id() == selected_id) {
+     // Save the iterator. Since we're using a GtkTreeStore, we're
+     // guaranteed that the iterator will remain valid as long as the above
+     // appended item exists.
+     *selected_iter = iter;
+  }
+
+  for (int i = 0; i < node->GetChildCount(); ++i) {
+    AddToTreeStoreAt(node->GetChild(i), selected_id, store,
+                     selected_iter, &iter);
+  }
 }
 
 BookmarkNode* CommitTreeStoreDifferencesBetween(
diff --git a/chrome/browser/gtk/bookmark_tree_model.h b/chrome/browser/gtk/bookmark_tree_model.h
index b7adafc..4ca0c5b 100644
--- a/chrome/browser/gtk/bookmark_tree_model.h
+++ b/chrome/browser/gtk/bookmark_tree_model.h
@@ -27,7 +27,7 @@ enum FolderTreeStoreColumns {
 // Make a tree store that has two columns: name and id.
 GtkTreeStore* MakeFolderTreeStore();
 
-// Copies the tree of folders rooted at |node| into a GtkTreeStore. We
+// Copies the folders in the model's root node into a GtkTreeStore. We
 // want the user to be able to modify the tree of folders, but to be able to
 // click Cancel and discard their modifications. |selected_id| is the
 // node->id() of the BookmarkNode that should selected on
@@ -39,6 +39,12 @@ GtkTreeStore* MakeFolderTreeStore();
 void AddToTreeStore(BookmarkModel* model, int selected_id,
                     GtkTreeStore* store, GtkTreeIter* selected_iter);
 
+// As above, but inserts just the tree rooted at |node| as a child of |parent|.
+// If |parent| is NULL, add it at the top level.
+void AddToTreeStoreAt(BookmarkNode* node, int selected_id,
+                      GtkTreeStore* store, GtkTreeIter* selected_iter,
+                      GtkTreeIter* parent);
+
 // Commits changes to a GtkTreeStore built from BuildTreeStoreFrom() back
 // into the BookmarkModel it was generated from.  Returns the BookmarkNode that
 // represented by |selected|.