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

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 450 matching lines @@
 }
 
 string16 GetNameForURL(const GURL& url) {
   if (url.is_valid()) {
     return net::GetSuggestedFilename(url, "", "", "", "", std::string());
   } 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(), PruneInvisibleFolders);
+  ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node());
 
   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 permanent nodes if there is space. The permanent nodes are the
     // only children of the root_node.
     const BookmarkNode* root_node = model->root_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()) {
+      if (find(nodes.begin(), nodes.end(), node) == nodes.end()) {
         nodes.push_back(node);
 
         if (nodes.size() == max_count)
           break;
       }
     }
   }
   return nodes;
 }
 
@@ skipping 256 matching lines @@
 void RecordBookmarkLaunch(BookmarkLaunchLocation location) {
 #if defined(OS_WIN)
   // TODO(estade): do this on other platforms too. For now it's compiled out
   // so that stats from platforms for which this is incompletely implemented
   // don't mix in with Windows, where it should be implemented exhaustively.
   UMA_HISTOGRAM_ENUMERATION("Bookmarks.LaunchLocation", location, LAUNCH_LIMIT);
 #endif
 }
 
 }  // namespace bookmark_utils