Support folders in bookmark search

chrome/browser/resources/bookmark_manager/js/main.js

 // 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.
 
 (function() {
 /** @const */ var BookmarkList = bmm.BookmarkList;
 /** @const */ var BookmarkTree = bmm.BookmarkTree;
 /** @const */ var Command = cr.ui.Command;
 /** @const */ var CommandBinding = cr.ui.CommandBinding;
 /** @const */ var LinkKind = cr.LinkKind;
@@ skipping 806 matching lines @@
   var bookmarkNodes = getSelectedBookmarkNodes();
   // If we double clicked or pressed enter on a single folder, navigate to it.
   if (bookmarkNodes.length == 1 && bmm.isFolder(bookmarkNodes[0])) {
     navigateTo(bookmarkNodes[0].id, updateHash);
   } else {
     openBookmarks(LinkKind.FOREGROUND_TAB);
   }
 }
 
 /**
+ * Refreshes search results after delete or undo-delete.
+ * This ensures children of deleted folders do not remain in results
+ */
+function updateSearchResults() {
+  if (list.isSearch()) {
+    list.reload();
+  }
+}
+
+/**
  * Deletes the selected bookmarks. The bookmarks are saved in memory in case
  * the user needs to undo the deletion.
  */
 function deleteBookmarks() {
   var selectedIds = getSelectedBookmarkIds();
+  var filteredIds = getFilteredSelectedBookmarkIds();
   lastDeletedNodes = [];
 
   function performDelete() {
-    chrome.bookmarkManagerPrivate.removeTrees(selectedIds);
+    // Only remove filtered ids.
+    chrome.bookmarkManagerPrivate.removeTrees(filteredIds);
     $('undo-delete-command').canExecuteChange();
     performGlobalUndo = undoDelete;
   }
 
   // First, store information about the bookmarks being deleted.
+  // Store all selected ids.
   selectedIds.forEach(function(id) {
     chrome.bookmarks.getSubTree(id, function(results) {
       lastDeletedNodes.push(results);
 
       // When all nodes have been saved, perform the deletion.
-      if (lastDeletedNodes.length === selectedIds.length)
+      if (lastDeletedNodes.length === selectedIds.length) {
         performDelete();
+        updateSearchResults();
+      }
     });
   });
 }
 
 /**
  * Restores a tree of bookmarks under a specified folder.
  * @param {BookmarkTreeNode} node The node to restore.
  * @param {=string} parentId The ID of the folder to restore under. If not
  *     specified, the original parentId of the node will be used.
  */
@@ skipping 10 matching lines @@
       console.error('Failed to restore bookmark.');
       return;
     }
 
     if (node.children) {
       // Restore the children using the new ID for this node.
       node.children.forEach(function(child) {
         restoreTree(child, result.id);
       });
     }
+
+    updateSearchResults();
   });
 }
 
 /**
  * Restores the last set of bookmarks that was deleted.
  */
 function undoDelete() {
   lastDeletedNodes.forEach(function(arr) {
     arr.forEach(restoreTree);
   });
@@ skipping 186 matching lines @@
  * if it was called from Organize Menu or from Context Menu.
  * @param {string} id The id of the element being pasted from.
  */
 function pasteBookmark(id) {
   recordUserAction('Paste');
   selectItemsAfterUserAction(list);
   chrome.bookmarkManagerPrivate.paste(id, getSelectedBookmarkIds());
 }
 
 /**
+ * Returns true if child is contained in another selected folder.
+ * Traces parent nodes up the tree until a selected ancestor or root is found.
+ */
+function hasSelectedAncestor(parentNode) {
+  function contains(arr, item) {
+    for (var i = 0; i < arr.length; i++)
+        if (arr[i] === item)
+          return true;
+    return false;
+  }
+
+  // Don't search top level, cannot select permanent nodes in search.
+  if (parentNode == null || parentNode.id <= 2)
+    return false;
+
+  // Found selected ancestor.
+  if (contains(getSelectedBookmarkNodes(), parentNode))
+    return true;
+
+  // Keep digging.
+  return hasSelectedAncestor(tree.getBookmarkNodeById(parentNode.parentId));
+}
+
+function getFilteredSelectedBookmarkIds() {
+  // Remove duplicates from filteredIds and return.
+  var filteredIds = new Array();
+  // Selected nodes to iterate through for matches.
+  var nodes = getSelectedBookmarkNodes();
+
+  for (var i = 0; i < nodes.length; i++)
+    if (!hasSelectedAncestor(tree.getBookmarkNodeById(nodes[i].parentId)))
+      filteredIds.splice(0, 0, nodes[i].id);
+
+  return filteredIds;
+}
+
+/**
  * Handler for the command event. This is used for context menu of list/tree
  * and organized menu.
  * @param {!Event} e The event object.
  */
 function handleCommand(e) {
   var command = e.command;
   var commandId = command.id;
   switch (commandId) {
     case 'import-menu-command':
       recordUserAction('Import');
@@ skipping 33 matching lines @@
       deleteBookmarks();
       break;
     case 'copy-command':
       recordUserAction('Copy');
       chrome.bookmarkManagerPrivate.copy(getSelectedBookmarkIds(),
                                          updatePasteCommand);
       break;
     case 'cut-command':
       recordUserAction('Cut');
       chrome.bookmarkManagerPrivate.cut(getSelectedBookmarkIds(),
-                                        updatePasteCommand);
+                                        function() {
+                                          updatePasteCommand();
+                                          updateSearchResults();
+                                        });
       break;
     case 'paste-from-organize-menu-command':
       pasteBookmark(list.parentId);
       break;
     case 'paste-from-context-menu-command':
       pasteBookmark(getSelectedId());
       break;
     case 'sort-command':
       recordUserAction('Sort');
       chrome.bookmarkManagerPrivate.sortChildren(list.parentId);
@@ skipping 155 matching lines @@
 
   cr.ui.FocusOutlineManager.forDocument(document);
   initializeSplitter();
   bmm.addBookmarkModelListeners();
   dnd.init(selectItemsAfterUserAction);
   tree.reload();
 }
 
 initializeBookmarkManager();
 })();