DO NOT SUBMIT: what chrome/browser/resources/ could eventually look like with clang-format

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() {
 'use strict';
 
 /** @const */ var BookmarkList = bmm.BookmarkList;
 /** @const */ var BookmarkTree = bmm.BookmarkTree;
 /** @const */ var Command = cr.ui.Command;
@@ skipping 43 matching lines @@
 /**
  * Whether bookmarks can be modified.
  * @type {boolean}
  */
 var canEdit = true;
 
 /**
  * @type {TreeItem}
  * @const
  */
-var searchTreeItem = new TreeItem({
-  bookmarkId: 'q='
-});
+var searchTreeItem = new TreeItem({bookmarkId: 'q='});
 
 /**
  * @type {boolean}
  */
 var firstLoad = true;
 
 /**
  * Command shortcut mapping.
  * @const
  */
-var commandShortcutMap = cr.isMac ? {
-  'edit': 'Enter',
-  // On Mac we also allow Meta+Backspace.
-  'delete': 'Delete Backspace Meta|Backspace',
-  'open-in-background-tab': 'Meta|Enter',
-  'open-in-new-tab': 'Shift|Meta|Enter',
-  'open-in-same-window': 'Meta|Down',
-  'open-in-new-window': 'Shift|Enter',
-  'rename-folder': 'Enter',
-  // Global undo is Command-Z. It is not in any menu.
-  'undo': 'Meta|z',
-} : {
-  'edit': 'F2',
-  'delete': 'Delete',
-  'open-in-background-tab': 'Ctrl|Enter',
-  'open-in-new-tab': 'Shift|Ctrl|Enter',
-  'open-in-same-window': 'Enter',
-  'open-in-new-window': 'Shift|Enter',
-  'rename-folder': 'F2',
-  // Global undo is Ctrl-Z. It is not in any menu.
-  'undo': 'Ctrl|z',
-};
+var commandShortcutMap = cr.isMac ?
+    {
+      'edit': 'Enter',
+      // On Mac we also allow Meta+Backspace.
+      'delete': 'Delete Backspace Meta|Backspace',
+      'open-in-background-tab': 'Meta|Enter',
+      'open-in-new-tab': 'Shift|Meta|Enter',
+      'open-in-same-window': 'Meta|Down',
+      'open-in-new-window': 'Shift|Enter',
+      'rename-folder': 'Enter',
+      // Global undo is Command-Z. It is not in any menu.
+      'undo': 'Meta|z',
+    } :
+    {
+      'edit': 'F2',
+      'delete': 'Delete',
+      'open-in-background-tab': 'Ctrl|Enter',
+      'open-in-new-tab': 'Shift|Ctrl|Enter',
+      'open-in-same-window': 'Enter',
+      'open-in-new-window': 'Shift|Enter',
+      'rename-folder': 'F2',
+      // Global undo is Ctrl-Z. It is not in any menu.
+      'undo': 'Ctrl|z',
+    };
 
 /**
  * Mapping for folder id to suffix of UMA. These names will be appeared
  * after "BookmarkManager_NavigateTo_" in UMA dashboard.
  * @const
  */
 var folderMetricsNameMap = {
   '1': 'BookmarkBar',
   '2': 'Other',
   '3': 'Mobile',
@@ skipping 47 matching lines @@
 function navigateTo(id, opt_callback) {
   window.location.hash = id;
 
   var sameParent = bmm.list.parentId == id;
   if (!sameParent)
     updateParentId(id);
 
   updateAllCommands();
 
   var metricsId = folderMetricsNameMap[id.replace(/^q=.*/, 'q=')] ||
-                  folderMetricsNameMap['subfolder'];
+      folderMetricsNameMap['subfolder'];
   chrome.metricsPrivate.recordUserAction(
       'BookmarkManager_NavigateTo_' + metricsId);
 
   if (opt_callback) {
     if (sameParent)
       opt_callback();
     else
       addOneShotEventListener(bmm.list, 'load', opt_callback);
   }
 }
@@ skipping 245 matching lines @@
     var singular = selectedNodes.length == 1 && !bmm.isFolder(selectedNodes[0]);
     command.label = loadTimeData.getString(singular ? singularId : pluralId);
   }
 
   if (commandDisabled) {
     command.disabled = true;
     e.canExecute = false;
     return;
   }
 
-  getUrlsForOpenCommands(assertInstanceof(e.target, HTMLElement)).then(
-      function(urls) {
-    var disabled = !urls.length;
-    command.disabled = disabled;
-    e.canExecute = !disabled;
-  });
+  getUrlsForOpenCommands(assertInstanceof(e.target, HTMLElement))
+      .then(function(urls) {
+        var disabled = !urls.length;
+        command.disabled = disabled;
+        e.canExecute = !disabled;
+      });
 }
 
 /**
  * Calls the backend to figure out if we can paste the clipboard into the active
  * folder.
  * @param {Function=} opt_f Function to call after the state has been updated.
  */
 function updatePasteCommand(opt_f) {
   function update(commandId, canPaste) {
     $(commandId).disabled = !canPaste;
@@ skipping 33 matching lines @@
   Promise.all(promises).then(function() {
     var cmd;
     if (document.activeElement == bmm.list)
       cmd = 'paste-from-organize-menu-command';
     else if (document.activeElement == bmm.tree)
       cmd = 'paste-from-folders-menu-command';
 
     if (cmd)
       update('paste-from-context-menu-command', !$(cmd).disabled);
 
-    if (opt_f) opt_f();
+    if (opt_f)
+      opt_f();
   });
 }
 
 function handleCanExecuteForSearchBox(e) {
   var command = e.command;
   switch (command.id) {
     case 'delete-command':
     case 'undo-command':
       // Pass the delete and undo commands through
       // (fixes http://crbug.com/278112).
       e.canExecute = false;
       break;
   }
 }
 
 function handleCanExecuteForDocument(e) {
   var command = e.command;
   switch (command.id) {
     case 'import-menu-command':
       e.canExecute = canEdit;
       break;
 
     case 'export-menu-command':
       // We can always execute the export-menu command.
       e.canExecute = true;
       break;
 
     case 'sort-command':
-      e.canExecute = !bmm.list.isSearch() &&
-          bmm.list.dataModel && bmm.list.dataModel.length > 1 &&
+      e.canExecute = !bmm.list.isSearch() && bmm.list.dataModel &&
+          bmm.list.dataModel.length > 1 &&
           !isUnmodifiable(bmm.tree.getBookmarkNodeById(bmm.list.parentId));
       break;
 
     case 'undo-command':
       // Because the global undo command has no visible UI, always enable it,
       // and just make it a no-op if undo is not possible.
       e.canExecute = true;
       break;
 
     default:
@@ skipping 16 matching lines @@
     case 'paste-from-folders-menu-command':
     case 'paste-from-organize-menu-command':
     case 'paste-from-context-menu-command':
       updatePasteCommand();
       break;
 
     case 'add-new-bookmark-command':
     case 'new-folder-command':
     case 'new-folder-from-folders-menu-command':
       var parentId = computeParentFolderForNewItem();
-      var unmodifiable = isUnmodifiable(
-          bmm.tree.getBookmarkNodeById(parentId));
+      var unmodifiable = isUnmodifiable(bmm.tree.getBookmarkNodeById(parentId));
       e.canExecute = !isSearch && canEdit && !unmodifiable;
       break;
 
     case 'open-in-new-tab-command':
       updateOpenCommand(e, command, 'open_in_new_tab', 'open_all', false);
       break;
 
     case 'open-in-background-tab-command':
       updateOpenCommand(e, command, '', '', false);
       break;
 
     case 'open-in-new-window-command':
-      updateOpenCommand(e, command,
-          'open_in_new_window', 'open_all_new_window',
+      updateOpenCommand(
+          e, command, 'open_in_new_window', 'open_all_new_window',
           // Disabled when incognito is forced.
           incognitoModeAvailability == 'forced');
       break;
 
     case 'open-incognito-window-command':
-      updateOpenCommand(e, command,
-          'open_incognito', 'open_all_incognito',
+      updateOpenCommand(
+          e, command, 'open_incognito', 'open_all_incognito',
           // Not available when incognito is disabled.
           incognitoModeAvailability == 'disabled');
       break;
 
     case 'undo-delete-command':
       e.canExecute = !!lastDeleted;
       break;
   }
 }
 
@@ skipping 50 matching lines @@
         command.hidden = isFolder;
       }
       break;
 
     case 'show-in-folder-command':
       e.canExecute = isSearch() && hasSingleSelected();
       break;
 
     case 'delete-command':
     case 'cut-command':
-      e.canExecute = canCopyItems() && canEdit &&
-          !hasUnmodifiable(bmm.list.selectedItems);
+      e.canExecute =
+          canCopyItems() && canEdit && !hasUnmodifiable(bmm.list.selectedItems);
       break;
 
     case 'copy-command':
       e.canExecute = canCopyItems();
       break;
 
     case 'open-in-same-window-command':
       e.canExecute = (e.target == bmm.list) && hasSelected();
       break;
 
     default:
       canExecuteShared(e, isSearch());
   }
 }
 
 // Update canExecute for the commands when the list is the active element.
 function handleCanExecuteForList(e) {
-  if (e.target != bmm.list) return;
+  if (e.target != bmm.list)
+    return;
   canExecuteForList(e);
 }
 
 // Update canExecute for the commands when the tree is the active element.
 function handleCanExecuteForTree(e) {
-  if (e.target != bmm.tree) return;
+  if (e.target != bmm.tree)
+    return;
   canExecuteForTree(e);
 }
 
 function canExecuteForTree(e) {
   function hasSelected() {
     return !!bmm.tree.selectedItem;
   }
 
   function isSearch() {
     return bmm.tree.selectedItem == searchTreeItem;
   }
 
   function isTopLevelItem() {
     return bmm.tree.selectedItem &&
-           bmm.tree.selectedItem.parentNode == bmm.tree;
+        bmm.tree.selectedItem.parentNode == bmm.tree;
   }
 
   var command = e.command;
   switch (command.id) {
     case 'rename-folder-command':
     case 'rename-folder-from-folders-menu-command':
       command.hidden = false;
       e.canExecute = hasSelected() && !isTopLevelItem() && canEdit &&
           !hasUnmodifiable(bmm.tree.selectedFolders);
       break;
@@ skipping 78 matching lines @@
 function handleRename(e) {
   var item = e.target;
   var bookmarkNode = item.bookmarkNode;
   chrome.bookmarks.update(bookmarkNode.id, {title: item.label});
   performGlobalUndo = null;  // This can't be undone, so disable global undo.
 }
 
 function handleEdit(e) {
   var item = e.target;
   var bookmarkNode = item.bookmarkNode;
-  var context = {
-    title: bookmarkNode.title
-  };
+  var context = {title: bookmarkNode.title};
   if (!bmm.isFolder(bookmarkNode))
     context.url = bookmarkNode.url;
 
   if (bookmarkNode.id == 'new') {
-    selectItemsAfterUserAction(/** @type {BookmarkList} */(bmm.list));
+    selectItemsAfterUserAction(/** @type {BookmarkList} */ (bmm.list));
 
     // New page
     context.parentId = bookmarkNode.parentId;
     chrome.bookmarks.create(context, function(node) {
       // A new node was created and will get added to the list due to the
       // handler.
       var dataModel = bmm.list.dataModel;
       var index = dataModel.indexOf(bookmarkNode);
       dataModel.splice(index, 1);
 
@@ skipping 59 matching lines @@
 
 /**
  * Returns the selected bookmark nodes of the provided tree or list.
  * If |opt_target| is not provided or null the active element is used.
  * Only call this if the list or the tree is focused.
  * @param {EventTarget=} opt_target The target list or tree.
  * @return {!Array} Array of bookmark nodes.
  */
 function getSelectedBookmarkNodes(opt_target) {
   return (opt_target || document.activeElement) == bmm.tree ?
-      bmm.tree.selectedFolders : bmm.list.selectedItems;
+      bmm.tree.selectedFolders :
+      bmm.list.selectedItems;
 }
 
 /**
  * @param {EventTarget=} opt_target The target list or tree.
  * @return {!Array<string>} An array of the selected bookmark IDs.
  */
 function getSelectedBookmarkIds(opt_target) {
   var selectedNodes = getSelectedBookmarkNodes(opt_target);
-  selectedNodes.sort(function(a, b) { return a.index - b.index; });
+  selectedNodes.sort(function(a, b) {
+    return a.index - b.index;
+  });
   return selectedNodes.map(function(node) {
     return node.id;
   });
 }
 
 /**
  * @param {BookmarkTreeNode} node The node to test.
  * @return {boolean} Whether the given node is unmodifiable.
  */
 function isUnmodifiable(node) {
@@ skipping 130 matching lines @@
 }
 
 /**
  * Computes folder for "Add Page" and "Add Folder".
  * @return {string} The id of folder node where we'll create new page/folder.
  */
 function computeParentFolderForNewItem() {
   if (document.activeElement == bmm.tree)
     return bmm.list.parentId;
   var selectedItem = bmm.list.selectedItem;
-  return selectedItem && bmm.isFolder(selectedItem) ?
-      selectedItem.id : bmm.list.parentId;
+  return selectedItem && bmm.isFolder(selectedItem) ? selectedItem.id :
+                                                      bmm.list.parentId;
 }
 
 /**
  * Callback for rename folder and edit command. This starts editing for
  * the passed in target, or the selected item.
  * @param {EventTarget=} opt_target The target to start editing. If absent or
  *     null, the selected item will be edited instead.
  */
 function editItem(opt_target) {
   if ((opt_target || document.activeElement) == bmm.tree) {
@@ skipping 15 matching lines @@
 
   var parentId = computeParentFolderForNewItem();
   var selectedItems = bmm.list.selectedItems;
   var newIndex;
   // Callback is called after tree and list data model updated.
   function createFolder(callback) {
     if (selectedItems.length == 1 && document.activeElement != bmm.tree &&
         !bmm.isFolder(selectedItems[0]) && selectedItems[0].id != 'new') {
       newIndex = bmm.list.dataModel.indexOf(selectedItems[0]) + 1;
     }
-    chrome.bookmarks.create({
-      title: loadTimeData.getString('new_folder_name'),
-      parentId: parentId,
-      index: newIndex
-    }, callback);
+    chrome.bookmarks.create(
+        {
+          title: loadTimeData.getString('new_folder_name'),
+          parentId: parentId,
+          index: newIndex
+        },
+        callback);
   }
 
   if ((opt_target || document.activeElement) == bmm.tree) {
     createFolder(function(newNode) {
       navigateTo(newNode.id, function() {
         bmm.treeLookup[newNode.id].editing = true;
       });
     });
     return;
   }
@@ skipping 32 matching lines @@
 function addPage() {
   var parentId = computeParentFolderForNewItem();
   var selectedItems = bmm.list.selectedItems;
   var newIndex;
   function editNewBookmark() {
     if (selectedItems.length == 1 && document.activeElement != bmm.tree &&
         !bmm.isFolder(selectedItems[0])) {
       newIndex = bmm.list.dataModel.indexOf(selectedItems[0]) + 1;
     }
 
-    var fakeNode = {
-      title: '',
-      url: '',
-      parentId: parentId,
-      index: newIndex,
-      id: 'new'
-    };
+    var fakeNode =
+        {title: '', url: '', parentId: parentId, index: newIndex, id: 'new'};
     var dataModel = bmm.list.dataModel;
     var index = dataModel.length;
     if (newIndex != undefined)
       index = newIndex;
     dataModel.splice(index, 0, fakeNode);
     var sm = bmm.list.selectionModel;
     sm.anchorIndex = sm.leadIndex = sm.selectedIndex = index;
     scrollIntoViewAndMakeEditable(index);
   }
 
@@ skipping 63 matching lines @@
 /**
  * The currently selected bookmark, based on where the user is clicking.
  * @return {string} The ID of the currently selected bookmark (could be from
  *     tree view or list view).
  */
 function getSelectedId() {
   if (document.activeElement == bmm.tree)
     return bmm.tree.selectedItem.bookmarkId;
   var selectedItem = bmm.list.selectedItem;
   return selectedItem && bmm.isFolder(selectedItem) ?
-      selectedItem.id : bmm.tree.selectedItem.bookmarkId;
+      selectedItem.id :
+      bmm.tree.selectedItem.bookmarkId;
 }
 
 /**
  * Pastes the copied/cutted bookmark into the right location depending whether
  * 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(/** @type {BookmarkList} */(bmm.list));
+  selectItemsAfterUserAction(/** @type {BookmarkList} */ (bmm.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;
+      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(
-      bmm.tree.getBookmarkNodeById(parentNode.parentId));
+  return hasSelectedAncestor(bmm.tree.getBookmarkNodeById(parentNode.parentId));
 }
 
 /**
  * @param {EventTarget=} opt_target A target to get bookmark IDs from.
  * @return {Array<string>} An array of bookmarks IDs.
  */
 function getFilteredSelectedBookmarkIds(opt_target) {
   // Remove duplicates from filteredIds and return.
   var filteredIds = [];
   // Selected nodes to iterate through for matches.
@@ skipping 59 matching lines @@
       target = bmm.tree;
     case 'delete-command':
       recordUserAction('Delete');
       deleteBookmarks(target);
       break;
 
     case 'copy-from-folders-menu-command':
       target = bmm.tree;
     case 'copy-command':
       recordUserAction('Copy');
-      chrome.bookmarkManagerPrivate.copy(getSelectedBookmarkIds(target),
-                                         updatePasteCommand);
+      chrome.bookmarkManagerPrivate.copy(
+          getSelectedBookmarkIds(target), updatePasteCommand);
       break;
 
     case 'cut-from-folders-menu-command':
       target = bmm.tree;
     case 'cut-command':
       recordUserAction('Cut');
-      chrome.bookmarkManagerPrivate.cut(getSelectedBookmarkIds(target),
-                                        function() {
-                                          updatePasteCommand();
-                                          updateSearchResults();
-                                        });
+      chrome.bookmarkManagerPrivate.cut(
+          getSelectedBookmarkIds(target), function() {
+            updatePasteCommand();
+            updateSearchResults();
+          });
       break;
 
     case 'paste-from-organize-menu-command':
       pasteBookmark(bmm.list.parentId);
       break;
 
     case 'paste-from-folders-menu-command':
       pasteBookmark(bmm.tree.selectedItem.bookmarkId);
       break;
 
@@ skipping 112 matching lines @@
   bmm.list.addEventListener('rename', handleRename);
   bmm.list.addEventListener('urlClicked', handleUrlClickedForList);
 
   bmm.tree.addEventListener('canExecute', handleCanExecuteForTree);
   bmm.tree.addEventListener('change', handleChangeForTree);
   bmm.tree.addEventListener('contextmenu', updateEditingCommands);
   bmm.tree.addEventListener('rename', handleRename);
   bmm.tree.addEventListener('load', handleLoadForTree);
 
   cr.ui.contextMenuHandler.addContextMenuProperty(
-      /** @type {!Element} */(bmm.tree));
+      /** @type {!Element} */ (bmm.tree));
   bmm.list.contextMenu = $('context-menu');
   bmm.tree.contextMenu = $('context-menu');
 
   // We listen to hashchange so that we can update the currently shown folder
   // when // the user goes back and forward in the history.
   window.addEventListener('hashchange', processHash);
 
   document.querySelector('header form').onsubmit =
-      /** @type {function(Event=)} */(function(e) {
-    setSearch($('term').value);
-    e.preventDefault();
-  });
+      /** @type {function(Event=)} */ (function(e) {
+        setSearch($('term').value);
+        e.preventDefault();
+      });
 
   $('term').addEventListener('search', handleSearch);
   $('term').addEventListener('canExecute', handleCanExecuteForSearchBox);
 
   $('folders-button').addEventListener('click', handleMenuButtonClicked);
   $('organize-button').addEventListener('click', handleMenuButtonClicked);
 
   document.addEventListener('canExecute', handleCanExecuteForDocument);
   document.addEventListener('command', handleCommand);
 
@@ skipping 28 matching lines @@
 
   cr.ui.FocusOutlineManager.forDocument(document);
   initializeSplitter();
   bmm.addBookmarkModelListeners();
   dnd.init(selectItemsAfterUserAction);
   bmm.tree.reload();
 }
 
 initializeBookmarkManager();
 })();