Permanent folders changes

chrome/browser/bookmarks/bookmark_utils.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 "chrome/browser/bookmarks/bookmark_utils.h"
 
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
@@ skipping 451 matching lines @@
 }
 
 string16 GetNameForURL(const GURL& url) {
   if (url.is_valid()) {
     return net::GetSuggestedFilename(url, "", "", "", "", string16());
   } else {
     return l10n_util::GetStringUTF16(IDS_APP_UNTITLED_SHORTCUT_FILE_NAME);
   }
 }
 
+// This is used with a tree iterator to skip subtrees which are not visible.
+static bool PruneInvisibleFolders(const BookmarkNode* node) {
+  return !node->IsVisible();
+}
+
 std::vector<const BookmarkNode*> GetMostRecentlyModifiedFolders(
     BookmarkModel* model,
     size_t max_count) {
   std::vector<const BookmarkNode*> nodes;
-  ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node());
+  ui::TreeNodeIterator<const BookmarkNode>
+      iterator(model->root_node(), PruneInvisibleFolders);
+
   while (iterator.has_next()) {
     const BookmarkNode* parent = iterator.Next();
     if (parent->is_folder() && parent->date_folder_modified() > base::Time()) {
       if (max_count == 0) {
         nodes.push_back(parent);
       } else {
         std::vector<const BookmarkNode*>::iterator i =
             std::upper_bound(nodes.begin(), nodes.end(), parent,
                              &MoreRecentlyModified);
         if (nodes.size() < max_count || i != nodes.end()) {
           nodes.insert(i, parent);
           while (nodes.size() > max_count)
             nodes.pop_back();
         }
       }
     }  // else case, the root node, which we don't care about or imported nodes
        // (which have a time of 0).
   }
 
   if (nodes.size() < max_count) {
-    // Add the bookmark bar and other nodes if there is space.
-    if (find(nodes.begin(), nodes.end(), model->bookmark_bar_node()) ==
-        nodes.end()) {
-      nodes.push_back(model->bookmark_bar_node());
-    }
+    // Add the permanent nodes if there is space. The permanent nodes are the
+    // only children of the root_node.
+    const BookmarkNode* root_node = model->root_node();
 
-    if (nodes.size() < max_count &&
-        find(nodes.begin(), nodes.end(), model->other_node()) == nodes.end()) {
-      nodes.push_back(model->other_node());
-    }
+    for (int i = 0; i < root_node->child_count(); ++i) {
+      const BookmarkNode* node = root_node->GetChild(i);
+      if (node->IsVisible() &&
+          find(nodes.begin(), nodes.end(), node) == nodes.end()) {
+        nodes.push_back(node);
 
-    if (nodes.size() < max_count && model->synced_node()->IsVisible() &&
-        find(nodes.begin(), nodes.end(),
-             model->synced_node()) == nodes.end()) {
-      nodes.push_back(model->synced_node());
+        if (nodes.size() == max_count)
+          break;
+      }
     }
   }
   return nodes;
 }
 
 void GetMostRecentlyAddedEntries(BookmarkModel* model,
                                  size_t count,
                                  std::vector<const BookmarkNode*>* nodes) {
   ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node());
   while (iterator.has_next()) {
@@ skipping 249 matching lines @@
   // Remove all the bookmarks.
   for (size_t i = 0; i < bookmarks.size(); ++i) {
     const BookmarkNode* node = bookmarks[i];
     int index = node->parent()->GetIndexOf(node);
     if (index > -1)
       model->Remove(node->parent(), index);
   }
 }
 
 }  // namespace bookmark_utils