Support folders in bookmark search

chrome/browser/bookmarks/bookmark_utils.cc

 // Copyright (c) 2012 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/files/file_path.h"
@@ skipping 77 matching lines @@
       DoesBookmarkTextContainWords(net::FormatUrl(
           node->url(), languages, net::kFormatUrlOmitNothing,
           net::UnescapeRule::NORMAL, NULL, NULL, NULL), words);
 }
 
 // This is used with a tree iterator to skip subtrees which are not visible.
 bool PruneInvisibleFolders(const BookmarkNode* node) {
   return !node->IsVisible();
 }
 
+// This traces parents up to root, determines if node is contained in a
+// selected folder.
+bool HasSelectedAncestor(BookmarkModel* model,
+                         const std::vector<const BookmarkNode*>& selectedNodes,
+                         const BookmarkNode* node) {
+  if (!node || model->is_permanent_node(node))
+    return false;
+
+  for (size_t i = 0; i < selectedNodes.size(); ++i)
+    if (node->id() == selectedNodes[i]->id())
+      return true;
+
+  return HasSelectedAncestor(model, selectedNodes, node->parent());
+}
+
 }  // namespace
 
 namespace bookmark_utils {
 
 QueryFields::QueryFields() {}
 QueryFields::~QueryFields() {}
 
 void CloneBookmarkNode(BookmarkModel* model,
                        const std::vector<BookmarkNodeData::Element>& elements,
                        const BookmarkNode* parent,
                        int index_to_add_at,
                        bool reset_node_times) {
   if (!parent->is_folder() || !model) {
     NOTREACHED();
     return;
   }
   for (size_t i = 0; i < elements.size(); ++i) {
     CloneBookmarkNodeImpl(model, elements[i], parent, index_to_add_at + i,
                           reset_node_times);
   }
 }
 
 void CopyToClipboard(BookmarkModel* model,
                      const std::vector<const BookmarkNode*>& nodes,
                      bool remove_nodes) {
   if (nodes.empty())
     return;
 
-  BookmarkNodeData(nodes).WriteToClipboard(ui::CLIPBOARD_TYPE_COPY_PASTE);
+  // Create array of selected nodes with descendants filtered out.
+  std::vector<const BookmarkNode*> filteredNodes;
+  for (size_t i = 0; i < nodes.size(); ++i)
+    if (!HasSelectedAncestor(model, nodes, nodes[i]->parent()))
+      filteredNodes.push_back(nodes[i]);
+
+  BookmarkNodeData(filteredNodes).
+      WriteToClipboard(ui::CLIPBOARD_TYPE_COPY_PASTE);
 
   if (remove_nodes) {
 #if !defined(OS_ANDROID)
     ScopedGroupingAction group_cut(BookmarkUndoServiceFactory::GetForProfile(
         model->profile())->undo_manager());
 #endif
-    for (size_t i = 0; i < nodes.size(); ++i) {
-      int index = nodes[i]->parent()->GetIndexOf(nodes[i]);
+    for (size_t i = 0; i < filteredNodes.size(); ++i) {
+      int index = filteredNodes[i]->parent()->GetIndexOf(filteredNodes[i]);
       if (index > -1)
-        model->Remove(nodes[i]->parent(), index);
+        model->Remove(filteredNodes[i]->parent(), index);
     }
   }
 }
 
 void PasteFromClipboard(BookmarkModel* model,
                         const BookmarkNode* parent,
                         int index) {
   if (!parent)
     return;
 
@@ skipping 92 matching lines @@
   std::vector<base::string16> query_words;
   QueryParser parser;
   if (query.word_phrase_query) {
     parser.ParseQueryWords(base::i18n::ToLower(*query.word_phrase_query),
                            &query_words);
   }
 
   ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node());
   while (iterator.has_next()) {
     const BookmarkNode* node = iterator.Next();
-    if (!query_words.empty() &&
-        !DoesBookmarkContainWords(node, query_words, languages)) {
+    if ((!query_words.empty() &&
+        !DoesBookmarkContainWords(node, query_words, languages)) ||
+        model->is_permanent_node(node)) {
       continue;
     }
     if (query.url) {
       // Check against bare url spec and IDN-decoded url.
       if (!node->is_url() ||
           !(base::UTF8ToUTF16(node->url().spec()) == *query.url ||
             net::FormatUrl(
                 node->url(), languages, net::kFormatUrlOmitNothing,
                 net::UnescapeRule::NORMAL, NULL, NULL, NULL) == *query.url)) {
         continue;
@@ skipping 83 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