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

chrome/browser/resources/bookmark_manager/js/dnd.js

 // Copyright 2013 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.
 
 cr.define('dnd', function() {
   'use strict';
 
   /** @const */ var BookmarkList = bmm.BookmarkList;
   /** @const */ var ListItem = cr.ui.ListItem;
   /** @const */ var TreeItem = cr.ui.TreeItem;
 
   /**
    * Enumeration of valid drop locations relative to an element. These are
    * bit masks to allow combining multiple locations in a single value.
    * @enum {number}
    * @const
    */
-  var DropPosition = {
-    NONE: 0,
-    ABOVE: 1,
-    ON: 2,
-    BELOW: 4
-  };
+  var DropPosition = {NONE: 0, ABOVE: 1, ON: 2, BELOW: 4};
 
   /**
    * @type {Object} Drop information calculated in |handleDragOver|.
    */
   var dropDestination = null;
 
   /**
-    * @type {number} Timer id used to help minimize flicker.
-    */
+   * @type {number} Timer id used to help minimize flicker.
+   */
   var removeDropIndicatorTimer;
 
   /**
-    * The element currently targeted by a touch.
-    * @type {Element}
-    */
+   * The element currently targeted by a touch.
+   * @type {Element}
+   */
   var currentTouchTarget;
 
   /**
-    * The element that had a style applied it to indicate the drop location.
-    * This is used to easily remove the style when necessary.
-    * @type {Element}
-    */
+   * The element that had a style applied it to indicate the drop location.
+   * This is used to easily remove the style when necessary.
+   * @type {Element}
+   */
   var lastIndicatorElement;
 
   /**
-    * The style that was applied to indicate the drop location.
-    * @type {?string}
-    */
+   * The style that was applied to indicate the drop location.
+   * @type {?string}
+   */
   var lastIndicatorClassName;
 
   var dropIndicator = {
     /**
      * Applies the drop indicator style on the target element and stores that
      * information to easily remove the style in the future.
      */
     addDropIndicatorStyle: function(indicatorElement, position) {
-      var indicatorStyleName = position == DropPosition.ABOVE ? 'drag-above' :
-                               position == DropPosition.BELOW ? 'drag-below' :
-                               'drag-on';
+      var indicatorStyleName = position == DropPosition.ABOVE ?
+          'drag-above' :
+          position == DropPosition.BELOW ? 'drag-below' : 'drag-on';
 
       lastIndicatorElement = indicatorElement;
       lastIndicatorClassName = indicatorStyleName;
 
       indicatorElement.classList.add(indicatorStyleName);
     },
 
     /**
      * Clears the drop indicator style from the last element was the drop target
      * so the drop indicator is no longer for that element.
      */
     removeDropIndicatorStyle: function() {
       if (!lastIndicatorElement || !lastIndicatorClassName)
         return;
       lastIndicatorElement.classList.remove(lastIndicatorClassName);
       lastIndicatorElement = null;
       lastIndicatorClassName = null;
     },
 
     /**
-      * Displays the drop indicator on the current drop target to give the
-      * user feedback on where the drop will occur.
-      */
+     * Displays the drop indicator on the current drop target to give the
+     * user feedback on where the drop will occur.
+     */
     update: function(dropDest) {
       window.clearTimeout(removeDropIndicatorTimer);
 
       var indicatorElement = dropDest.element;
       var position = dropDest.position;
       if (dropDest.element instanceof BookmarkList) {
         // For an empty bookmark list use 'drop-above' style.
         position = DropPosition.ABOVE;
       } else if (dropDest.element instanceof TreeItem) {
         indicatorElement = indicatorElement.querySelector('.tree-row');
       }
       dropIndicator.removeDropIndicatorStyle();
       dropIndicator.addDropIndicatorStyle(indicatorElement, position);
     },
 
     /**
      * Stop displaying the drop indicator.
      */
     finish: function() {
       // The use of a timeout is in order to reduce flickering as we move
       // between valid drop targets.
       window.clearTimeout(removeDropIndicatorTimer);
       removeDropIndicatorTimer = window.setTimeout(function() {
         dropIndicator.removeDropIndicatorStyle();
       }, 100);
     }
   };
 
   /**
-    * Delay for expanding folder when pointer hovers on folder in tree view in
-    * milliseconds.
-    * @type {number}
-    * @const
-    */
+   * Delay for expanding folder when pointer hovers on folder in tree view in
+   * milliseconds.
+   * @type {number}
+   * @const
+   */
   // TODO(yosin): EXPAND_FOLDER_DELAY should follow system settings. 400ms is
   // taken from Windows default settings.
   var EXPAND_FOLDER_DELAY = 400;
 
   /**
-    * The timestamp when the mouse was over a folder during a drag operation.
-    * Used to open the hovered folder after a certain time.
-    * @type {number}
-    */
+   * The timestamp when the mouse was over a folder during a drag operation.
+   * Used to open the hovered folder after a certain time.
+   * @type {number}
+   */
   var lastHoverOnFolderTimeStamp = 0;
 
   /**
-    * Expand a folder if the user has hovered for longer than the specified
-    * time during a drag action.
-    */
+   * Expand a folder if the user has hovered for longer than the specified
+   * time during a drag action.
+   */
   function updateAutoExpander(eventTimeStamp, overElement) {
     // Expands a folder in tree view when pointer hovers on it longer than
     // EXPAND_FOLDER_DELAY.
     var hoverOnFolderTimeStamp = lastHoverOnFolderTimeStamp;
     lastHoverOnFolderTimeStamp = 0;
     if (hoverOnFolderTimeStamp) {
       if (eventTimeStamp - hoverOnFolderTimeStamp >= EXPAND_FOLDER_DELAY)
         overElement.expanded = true;
       else
         lastHoverOnFolderTimeStamp = hoverOnFolderTimeStamp;
-    } else if (overElement instanceof TreeItem &&
-                bmm.isFolder(overElement.bookmarkNode) &&
-                overElement.hasChildren &&
-                !overElement.expanded) {
+    } else if (
+        overElement instanceof TreeItem &&
+        bmm.isFolder(overElement.bookmarkNode) && overElement.hasChildren &&
+        !overElement.expanded) {
       lastHoverOnFolderTimeStamp = eventTimeStamp;
     }
   }
 
   /**
-    * Stores the information about the bookmark and folders being dragged.
-    * @type {Object}
-    */
+   * Stores the information about the bookmark and folders being dragged.
+   * @type {Object}
+   */
   var dragData = null;
   var dragInfo = {
     handleChromeDragEnter: function(newDragData) {
       dragData = newDragData;
     },
     clearDragData: function() {
       dragData = null;
     },
     isDragValid: function() {
       return !!dragData;
@@ skipping 165 matching lines @@
     e.preventDefault();
 
     // Do not allow dragging if there is an ephemeral item being edited at the
     // moment.
     if (bmm.list.hasEphemeral())
       return;
 
     if (draggedNodes.length) {
       // If we are dragging a single link, we can do the *Link* effect.
       // Otherwise, we only allow copy and move.
-      e.dataTransfer.effectAllowed = draggedNodes.length == 1 &&
-          !bmm.isFolder(draggedNodes[0]) ? 'copyMoveLink' : 'copyMove';
+      e.dataTransfer.effectAllowed =
+          draggedNodes.length == 1 && !bmm.isFolder(draggedNodes[0]) ?
+          'copyMoveLink' :
+          'copyMove';
 
-      chrome.bookmarkManagerPrivate.startDrag(draggedNodes.map(function(node) {
-        return node.id;
-      }), isFromTouch);
+      chrome.bookmarkManagerPrivate.startDrag(
+          draggedNodes.map(function(node) {
+            return node.id;
+          }),
+          isFromTouch);
       var dragTarget = getBookmarkElement(e.target);
       if (dragTarget instanceof ListItem ||
           dragTarget instanceof BookmarkList) {
         chrome.metricsPrivate.recordUserAction(
             'BookmarkManager_StartDragFromList');
       } else if (dragTarget instanceof TreeItem) {
         chrome.metricsPrivate.recordUserAction(
             'BookmarkManager_StartDragFromTree');
       }
 
@@ skipping 18 matching lines @@
       e.preventDefault();
 
       // Set to none. This will get set to something if we can do the drop.
       e.dataTransfer.dropEffect = 'none';
     }
 
     if (!dragInfo.isDragValid())
       return;
 
     var overElement = getBookmarkElement(e.target) ||
-                      (e.target == bmm.list ? bmm.list : null);
+        (e.target == bmm.list ? bmm.list : null);
     if (!overElement)
       return;
 
     updateAutoExpander(e.timeStamp, overElement);
 
     var canDropInfo = calculateValidDropTargets(overElement);
     if (canDropInfo == DropPosition.NONE)
       return;
 
     // Now we know that we can drop. Determine if we will drop above, on or
@@ skipping 44 matching lines @@
     return null;
   }
 
   function calculateDropInfo(eventTarget, dropDestination) {
     if (!dropDestination || !dragInfo.isDragValid())
       return null;
 
     var dropPos = dropDestination.position;
     var relatedNode = dropDestination.element.bookmarkNode;
     var dropInfoResult = {
-        selectTarget: null,
-        selectedTreeId: -1,
-        parentId: dropPos == DropPosition.ON ? relatedNode.id :
-                                               relatedNode.parentId,
-        index: -1,
-        relatedIndex: -1
-      };
+      selectTarget: null,
+      selectedTreeId: -1,
+      parentId: dropPos == DropPosition.ON ? relatedNode.id :
+                                             relatedNode.parentId,
+      index: -1,
+      relatedIndex: -1
+    };
 
     // Try to find the index in the dataModel so we don't have to always keep
     // the index for the list items up to date.
     var overElement = getBookmarkElement(eventTarget);
     if (overElement instanceof ListItem) {
       dropInfoResult.relatedIndex =
           overElement.parentNode.dataModel.indexOf(relatedNode);
       dropInfoResult.selectTarget = bmm.list;
     } else if (overElement instanceof BookmarkList) {
       dropInfoResult.relatedIndex = overElement.dataModel.length - 1;
@@ skipping 14 matching lines @@
     return dropInfoResult;
   }
 
   function handleDragLeave(e) {
     dropIndicator.finish();
   }
 
   function handleDrop(e) {
     var dropInfo = calculateDropInfo(e.target, dropDestination);
     if (dropInfo) {
-      selectItemsAfterUserAction(dropInfo.selectTarget,
-                                 dropInfo.selectedTreeId);
+      selectItemsAfterUserAction(
+          dropInfo.selectTarget, dropInfo.selectedTreeId);
       if (dropInfo.index != -1)
         chrome.bookmarkManagerPrivate.drop(dropInfo.parentId, dropInfo.index);
       else
         chrome.bookmarkManagerPrivate.drop(dropInfo.parentId);
 
       e.preventDefault();
 
       var dragTarget = getBookmarkElement(e.target);
       var action;
       if (dragTarget instanceof ListItem ||
@@ skipping 48 matching lines @@
     document.addEventListener('touchend', clearCurrentTouchTarget);
     document.addEventListener('touchstart', setCurrentTouchTarget);
 
     chrome.bookmarkManagerPrivate.onDragEnter.addListener(
         dragInfo.handleChromeDragEnter);
     chrome.bookmarkManagerPrivate.onDragLeave.addListener(deferredClearData);
     chrome.bookmarkManagerPrivate.onDrop.addListener(deferredClearData);
   }
   return {init: init};
 });