Use bookmark manager to add/edit bookmark pages with webui_dialogs=1.

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

 // 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.
 
 const BookmarkList = bmm.BookmarkList;
 const BookmarkTree = bmm.BookmarkTree;
 const ListItem = cr.ui.ListItem;
 const TreeItem = cr.ui.TreeItem;
 const LinkKind = cr.LinkKind;
 const Command = cr.ui.Command;
@@ skipping 98 matching lines @@
 });
 bmm.treeLookup[recentTreeItem.bookmarkId] = recentTreeItem;
 
 BookmarkTree.decorate(tree);
 
 tree.addEventListener('change', function() {
   navigateTo(tree.selectedItem.bookmarkId);
 });
 
 /**
+ * Add an event listener to a node that will remove itself after firing once.
+ * @param {!Element} node The DOM node to add the listener to.
+ * @param {string} name The name of the event listener to add to.
+ * @param {function(Event)} handler Function called when the event fires.
+ */
+function addOneShotEventListener(node, name, handler) {
+  var f = function(e) {
+    handler(e);
+    node.removeEventListener(name, f);
+  };
+  node.addEventListener(name, f);
+}
+
+/**
  * Navigates to a bookmark ID.
  * @param {string} id The ID to navigate to.
  * @param {boolean=} opt_updateHashNow Whether to immediately update the
  *     location.hash. If false then it is updated in a timeout.
  */
 function navigateTo(id, opt_updateHashNow) {
   console.info('navigateTo', 'from', window.location.hash, 'to', id);
   // Update the location hash using a timer to prevent reentrancy. This is how
   // often we add history entries and the time here is a bit arbitrary but was
   // picked as the smallest time a human perceives as instant.
@@ skipping 14 matching lines @@
 /**
  * Updates the parent ID of the bookmark list and selects the correct tree item.
  * @param {string} id The id.
  */
 function updateParentId(id) {
   list.parentId = id;
   if (id in bmm.treeLookup)
     tree.selectedItem = bmm.treeLookup[id];
 }
 
-// We listen to hashchange so that we can update the currently shown folder when
-// the user goes back and forward in the history.
-window.onhashchange = function(e) {
+// Process the location hash. This is called onhashchange and when the page is
+// first loaded.
+function processHash() {
   var id = window.location.hash.slice(1);
+  if (!id) {
+    // If we do not have a hash select first item in the tree.
+    id = tree.items[0].bookmarkId;
+  }
 
   var valid = false;
+  if (/^[ae]=/.test(id)) {
+    var command = id[0];
+    id = id.slice(2);
+    if (command == 'e') {
+      // If hash contains e= edit the item specified.
+      chrome.bookmarks.get(id, function(bookmarkNodes) {
+        // Verify the node to edit is a valid node.
+        if (!bookmarkNodes || bookmarkNodes.length != 1)
+          return;
+        var bookmarkNode = bookmarkNodes[0];
+        // After the list reloads edit the desired bookmark.
+        var editBookmark = function(e) {
+          var index = list.dataModel.findIndexById(bookmarkNode.id);
+          if (index != -1) {
+            var sm = list.selectionModel;
+            sm.anchorIndex = sm.leadIndex = sm.selectedIndex = index;
+            scrollIntoViewAndMakeEditable(index);
+          }
+        }
 
-  // In case we got a search hash update the text input and the bmm.treeLookup
-  // to use the new id.
-  if (/^q=/.test(id)) {
+        if (list.parentId == bookmarkNode.parentId)
+          editBookmark();
+        else {
+          // Navigate to the parent folder, once it's loaded edit the bookmark.
+          addOneShotEventListener(list, 'load', editBookmark);
+          updateParentId(bookmarkNode.parentId);
+        }
+      });
+      // We handle the two cases of navigating to the bookmark to be edited
+      // above, don't run the standard navigation code below.
+      return;
+    } else if (command == 'a') {
+      // Once the parent folder is loaded add a page bookmark.
+      addOneShotEventListener(list, 'load', addPage);
+    }
+  } else if (/^q=/.test(id)) {
+    // In case we got a search hash update the text input and the
+    // bmm.treeLookup to use the new id.
     setSearch(id.slice(2));
     valid = true;
   } else if (id == 'recent') {
     valid = true;
   }
 
+  // Navigate to bookmark 'id' (which may be a query of the form q=query).
   if (valid) {
     updateParentId(id);
   } else {
     // We need to verify that this is a correct ID.
     chrome.bookmarks.get(id, function(items) {
       if (items && items.length == 1)
         updateParentId(id);
     });
   }
 };
 
+// We listen to hashchange so that we can update the currently shown folder when
+// the user goes back and forward in the history.
+window.onhashchange = function(e) {
+  processHash();
+};
+
 // Activate is handled by the open-in-same-window-command.
 list.addEventListener('dblclick', function(e) {
   if (e.button == 0)
     $('open-in-same-window-command').execute();
 });
 
 // The list dispatches an event when the user clicks on the URL or the Show in
 // folder part.
 list.addEventListener('urlClicked', function(e) {
   getLinkController().openUrlFromEvent(e.url, e.originalEvent);
@@ skipping 150 matching lines @@
     if (parentNode.parentId != ROOT_ID) {
       return getFolder(parentNode.parentId) + '/' + s;
     }
     return s;
   }
 }
 
 tree.addEventListener('load', function(e) {
   // Add hard coded tree items
   tree.add(recentTreeItem);
-
-  // Now we can select a tree item.
-  var hash = window.location.hash.slice(1);
-  if (!hash) {
-    // If we do not have a hash select first item in the tree.
-    hash = tree.items[0].bookmarkId;
-  }
-
-  if (/^q=/.test(hash)) {
-    var searchTerm = hash.slice(2);
-    $('term').value = searchTerm;
-    setSearch(searchTerm);
-  } else {
-    navigateTo(hash);
-  }
+  processHash();
 });
 
 tree.reload();
 addBookmarkModelListeners();
 
 var dnd = {
   dragData: null,
 
   getBookmarkElement: function(el) {
     while (el && !el.bookmarkNode) {
@@ skipping 1238 matching lines @@
   document.addEventListener('copy', handle('copy-command'));
   document.addEventListener('cut', handle('cut-command'));
 
   var pasteHandler = handle('paste-command');
   document.addEventListener('paste', function(e) {
     // Paste is a bit special since we need to do an async call to see if we can
     // paste because the paste command might not be up to date.
     updatePasteCommand(pasteHandler);
   });
 })();