WIP: run clang-format-js on lots of things

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.
     */
   var removeDropIndicatorTimer;
@@ skipping 16 matching lines @@
     * @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.
@@ skipping 62 matching lines @@
   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}
     */
   var dragData = null;
   var dragInfo = {
@@ skipping 173 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};
 });