Change bookmarkManager API from experimental to private.

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.
 
 /** @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;
 /** @const */ var ListItem = cr.ui.ListItem;
 /** @const */ var Menu = cr.ui.Menu;
 /** @const */ var MenuButton  = cr.ui.MenuButton;
 /** @const */ var Promise = cr.Promise;
 /** @const */ var Splitter = cr.ui.Splitter;
 /** @const */ var TreeItem = cr.ui.TreeItem;
 
 // Sometimes the extension API is not initialized.
 if (!chrome.bookmarks)
   console.error('Bookmarks extension API is not available');
 
 // Get the localized strings from the backend.
-chrome.experimental.bookmarkManager.getStrings(function(data) {
+chrome.bookmarkManagerPrivate.getStrings(function(data) {
   // The strings may contain & which we need to strip.
   for (var key in data) {
     data[key] = data[key].replace(/&/, '');
   }
 
   loadTimeData.data = data;
   i18nTemplate.process(document, loadTimeData);
 
   recentTreeItem.label = loadTimeData.getString('recent');
   searchTreeItem.label = loadTimeData.getString('search');
@@ skipping 179 matching lines @@
 // 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);
-  chrome.experimental.bookmarkManager.recordLaunch();
+  chrome.bookmarkManagerPrivate.recordLaunch();
 });
 
 $('term').onsearch = function(e) {
   setSearch(this.value);
 };
 
 /**
  * Navigates to the search results for the search text.
  * @para {string} searchText The text to search for.
  */
@@ skipping 303 matching lines @@
         effectAllowed = 'copyMoveLink';
       } else {
         effectAllowed = 'copyMove';
       }
       e.dataTransfer.effectAllowed = effectAllowed;
 
       var ids = draggedNodes.map(function(node) {
         return node.id;
       });
 
-      chrome.experimental.bookmarkManager.startDrag(ids);
+      chrome.bookmarkManagerPrivate.startDrag(ids);
     }
   },
 
   handleDragEnter: function(e) {
     e.preventDefault();
   },
 
   /**
    * Calback for the dragover event.
    * @param {Event} e The dragover event.
@@ skipping 206 matching lines @@
       }
 
       if (dropPos == 'above')
         index = relatedIndex;
       else if (dropPos == 'below')
         index = relatedIndex + 1;
 
       selectItemsAfterUserAction(selectTarget, selectedTreeId);
 
       if (index != undefined && index != -1)
-        chrome.experimental.bookmarkManager.drop(parentId, index);
+        chrome.bookmarkManagerPrivate.drop(parentId, index);
       else
-        chrome.experimental.bookmarkManager.drop(parentId);
+        chrome.bookmarkManagerPrivate.drop(parentId);
 
       e.preventDefault();
 
       // TODO(arv): Select the newly dropped items.
     }
     this.dropDestination = null;
     this.hideDropOverlay_();
   },
 
   clearDragData: function() {
@@ skipping 11 matching lines @@
     }
 
     document.addEventListener('dragstart', this.handleDragStart.bind(this));
     document.addEventListener('dragenter', this.handleDragEnter.bind(this));
     document.addEventListener('dragover', this.handleDragOver.bind(this));
     document.addEventListener('dragleave', this.handleDragLeave.bind(this));
     document.addEventListener('drop', this.handleDrop.bind(this));
     document.addEventListener('dragend', deferredClearData);
     document.addEventListener('mouseup', deferredClearData);
 
-    chrome.experimental.bookmarkManager.onDragEnter.addListener(
+    chrome.bookmarkManagerPrivate.onDragEnter.addListener(
         this.handleChromeDragEnter.bind(this));
-    chrome.experimental.bookmarkManager.onDragLeave.addListener(
+    chrome.bookmarkManagerPrivate.onDragLeave.addListener(
         deferredClearData);
-    chrome.experimental.bookmarkManager.onDrop.addListener(deferredClearData);
+    chrome.bookmarkManagerPrivate.onDrop.addListener(deferredClearData);
   }
 };
 
 dnd.init();
 
 // Commands
 
 cr.ui.decorate('menu', Menu);
 cr.ui.decorate('button[menu]', MenuButton);
 cr.ui.decorate('command', Command);
 
 cr.ui.contextMenuHandler.addContextMenuProperty(tree);
 list.contextMenu = $('context-menu');
 tree.contextMenu = $('context-menu');
 
 // Disable almost all commands at startup.
 var commands = document.querySelectorAll('command');
 for (var i = 0, command; command = commands[i]; i++) {
   if (command.id != 'import-menu-command' &&
       command.id != 'export-menu-command') {
     command.disabled = true;
   }
 }
 
 var canEdit = true;
-chrome.experimental.bookmarkManager.canEdit(function(result) {
+chrome.bookmarkManagerPrivate.canEdit(function(result) {
   canEdit = result;
 });
 
 /**
  * Incognito mode availability can take the following values: ,
  *   - 'enabled' for when both normal and incognito modes are available;
  *   - 'disabled' for when incognito mode is disabled;
  *   - 'forced' for when incognito mode is forced (normal mode is unavailable).
  */
 var incognitoModeAvailability = 'enabled';
 chrome.systemPrivate.getIncognitoModeAvailability(function(result) {
   // TODO(rustema): propagate policy value to the bookmark manager when
   //                it changes.
   incognitoModeAvailability = result;
 });
 
 /**
  * New Windows are not allowed in Windows 8 metro mode.
  */
 var canOpenNewWindows = true;
-chrome.experimental.bookmarkManager.canOpenNewWindows(function(result) {
+chrome.bookmarkManagerPrivate.canOpenNewWindows(function(result) {
     canOpenNewWindows = result;
 });
 
 /**
  * Helper function that updates the canExecute and labels for the open-like
  * commands.
  * @param {!cr.ui.CanExecuteEvent} e The event fired by the command system.
  * @param {!cr.ui.Command} command The command we are currently processing.
  */
 function updateOpenCommands(e, command) {
@@ skipping 60 matching lines @@
   function update(canPaste) {
     var command = $('paste-command');
     command.disabled = !canPaste;
     if (opt_f)
       opt_f();
   }
   // We cannot paste into search and recent view.
   if (list.isSearch() || list.isRecent()) {
     update(false);
   } else {
-    chrome.experimental.bookmarkManager.canPaste(list.parentId, update);
+    chrome.bookmarkManagerPrivate.canPaste(list.parentId, update);
   }
 }
 
 document.addEventListener('canExecute', function(e) {
   var command = e.command;
   var commandId = command.id;
   if (commandId == 'import-menu-command') {
     e.canExecute = canEdit;
   } else if (commandId == 'export-menu-command') {
     // We can always execute the export-menu command.
@@ skipping 189 matching lines @@
   }
 }
 
 list.addEventListener('change', updateCommandsBasedOnSelection);
 tree.addEventListener('change', updateCommandsBasedOnSelection);
 
 function updateEditingCommands() {
   var editingCommands = ['cut', 'delete', 'rename-folder', 'edit',
       'add-new-bookmark', 'new-folder', 'sort', 'paste'];
 
-  chrome.experimental.bookmarkManager.canEdit(function(result) {
+  chrome.bookmarkManagerPrivate.canEdit(function(result) {
     if (result != canEdit) {
       canEdit = result;
       editingCommands.forEach(function(baseId) {
         $(baseId + '-command').canExecuteChange();
       });
     }
   });
 }
 
 var organizeButton = document.querySelector('.summary > button');
@@ skipping 168 matching lines @@
 
   var p = Promise.all.apply(null, promises);
   p.addListener(function(values) {
     values.forEach(function(v) {
       if (typeof v == 'string')
         urls.push(v);
       else
         addNodes(v);
     });
     getLinkController().openUrls(urls, kind);
-    chrome.experimental.bookmarkManager.recordLaunch();
+    chrome.bookmarkManagerPrivate.recordLaunch();
   });
 }
 
 /**
  * Opens an item in the list.
  */
 function openItem() {
   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])) {
@@ skipping 210 matching lines @@
     case 'open-in-new-window-command':
       openBookmarks(LinkKind.WINDOW);
       break;
     case 'open-incognito-window-command':
       openBookmarks(LinkKind.INCOGNITO);
       break;
     case 'delete-command':
       deleteBookmarks();
       break;
     case 'copy-command':
-      chrome.experimental.bookmarkManager.copy(getSelectedBookmarkIds(),
-                                               updatePasteCommand);
+      chrome.bookmarkManagerPrivate.copy(getSelectedBookmarkIds(),
+                                         updatePasteCommand);
       break;
     case 'cut-command':
-      chrome.experimental.bookmarkManager.cut(getSelectedBookmarkIds(),
-                                              updatePasteCommand);
+      chrome.bookmarkManagerPrivate.cut(getSelectedBookmarkIds(),
+                                        updatePasteCommand);
       break;
     case 'paste-command':
       selectItemsAfterUserAction(list);
-      chrome.experimental.bookmarkManager.paste(list.parentId,
-                                                getSelectedBookmarkIds());
+      chrome.bookmarkManagerPrivate.paste(list.parentId,
+                                          getSelectedBookmarkIds());
       break;
     case 'sort-command':
-      chrome.experimental.bookmarkManager.sortChildren(list.parentId);
+      chrome.bookmarkManagerPrivate.sortChildren(list.parentId);
       break;
     case 'rename-folder-command':
     case 'edit-command':
       if (document.activeElement == list) {
         var li = list.getListItem(list.selectedItem);
         if (li)
           li.editing = true;
       } else {
         document.activeElement.selectedItem.editing = true;
       }
@@ skipping 53 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);
   });
 })();