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

chrome/browser/resources/ntp4/tile_page.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.
 
 cr.define('ntp', function() {
   'use strict';
 
   // We can't pass the currently dragging tile via dataTransfer because of
   // http://crbug.com/31037
   var currentlyDraggingTile = null;
@@ skipping 102 matching lines @@
       e.dataTransfer.effectAllowed = 'copyMove';
       this.firstChild.setDragData(e.dataTransfer);
 
       // The drag clone is the node we use as a representation during the drag.
       // It's attached to the top level document element so that it floats above
       // image masks.
       this.dragClone = this.cloneNode(true);
       this.dragClone.style.right = '';
       this.dragClone.classList.add('drag-representation');
       $('card-slider-frame').appendChild(this.dragClone);
-      this.eventTracker.add(this.dragClone, 'webkitTransitionEnd',
-                            this.onDragCloneTransitionEnd_.bind(this));
+      this.eventTracker.add(
+          this.dragClone, 'webkitTransitionEnd',
+          this.onDragCloneTransitionEnd_.bind(this));
 
       this.classList.add('dragging');
       // offsetLeft is mirrored in RTL. Un-mirror it.
-      var offsetLeft = isRTL() ?
-          this.parentNode.clientWidth - this.offsetLeft :
-          this.offsetLeft;
+      var offsetLeft = isRTL() ? this.parentNode.clientWidth - this.offsetLeft :
+                                 this.offsetLeft;
       this.dragOffsetX = e.x - offsetLeft - this.parentNode.offsetLeft;
       this.dragOffsetY = e.y - this.offsetTop -
           // Unlike offsetTop, this value takes scroll position into account.
           this.parentNode.getBoundingClientRect().top;
 
       this.onDragMove_(e);
     },
 
     /**
      * The handler for drag events fired on |this|.
@@ skipping 32 matching lines @@
         this.dragClone.classList.add('deleting');
       } else if (tilePage) {
         // TODO(dbeam): Until we fix dropEffect to the correct behavior it will
         // differ on windows - crbug.com/39399.  That's why we use the custom
         // this.lastDropEffect instead of e.dataTransfer.dropEffect.
         if (tilePage.selected && this.lastDropEffect != 'copy') {
           // The drag clone can still be hidden from the last drag move event.
           this.dragClone.hidden = false;
           // The tile's contents may have moved following the respositioning;
           // adjust for that.
-          var contentDiffX = this.dragClone.firstChild.offsetLeft -
-              this.firstChild.offsetLeft;
-          var contentDiffY = this.dragClone.firstChild.offsetTop -
-              this.firstChild.offsetTop;
+          var contentDiffX =
+              this.dragClone.firstChild.offsetLeft - this.firstChild.offsetLeft;
+          var contentDiffY =
+              this.dragClone.firstChild.offsetTop - this.firstChild.offsetTop;
           this.dragClone.style.left =
-              toCssPx(this.gridX + this.parentNode.offsetLeft -
-                         contentDiffX);
-          this.dragClone.style.top =
-              toCssPx(this.gridY +
-                         this.parentNode.getBoundingClientRect().top -
-                         contentDiffY);
+              toCssPx(this.gridX + this.parentNode.offsetLeft - contentDiffX);
+          this.dragClone.style.top = toCssPx(
+              this.gridY + this.parentNode.getBoundingClientRect().top -
+              contentDiffY);
         } else if (this.dragClone.hidden) {
           this.finalizeDrag_();
         } else {
           // The CSS3 transitions spec intentionally leaves it up to individual
           // user agents to determine when styles should be applied. On some
           // platforms (at the moment, Windows), when you apply both classes
           // immediately a transition may not occur correctly. That's why we're
           // using a setTimeout here to queue adding the class until the
           // previous class (currently: .placing) sets up a transition.
           // http://dev.w3.org/csswg/css3-transitions/#starting
@@ skipping 27 matching lines @@
       for (var i = 0; i < clonelets.length; i++) {
         clonelets[i].classList.remove('real');
       }
 
       this.appendChild(clone);
       this.doppleganger_ = clone;
 
       if (isRTL())
         x *= -1;
 
-      this.doppleganger_.style.WebkitTransform = 'translate(' + x + 'px, ' +
-                                                                y + 'px)';
+      this.doppleganger_.style.WebkitTransform =
+          'translate(' + x + 'px, ' + y + 'px)';
     },
 
     /**
      * Destroys the current doppleganger.
      */
     clearDoppleganger: function() {
       if (this.doppleganger_) {
         this.removeChild(this.doppleganger_);
         this.doppleganger_ = null;
       }
@@ skipping 118 matching lines @@
   }
 
   /**
    * Takes a collection of grid layout pixel values and updates them with
    * additional tiling values that are calculated from TilePage constants.
    * @param {Object} grid The grid layout pixel values to update.
    */
   TilePage.initGridValues = function(grid) {
     // The amount of space we need to display a narrow grid (all narrow grids
     // are this size).
-    grid.narrowWidth =
-        grid.minTileWidth * tileWidthFraction(grid.minColCount,
-                                              grid.tileSpacingFraction);
+    grid.narrowWidth = grid.minTileWidth *
+        tileWidthFraction(grid.minColCount, grid.tileSpacingFraction);
     // The minimum amount of space we need to display a wide grid.
-    grid.minWideWidth =
-        grid.minTileWidth * tileWidthFraction(grid.maxColCount,
-                                              grid.tileSpacingFraction);
+    grid.minWideWidth = grid.minTileWidth *
+        tileWidthFraction(grid.maxColCount, grid.tileSpacingFraction);
     // The largest we will ever display a wide grid.
-    grid.maxWideWidth =
-        grid.maxTileWidth * tileWidthFraction(grid.maxColCount,
-                                              grid.tileSpacingFraction);
+    grid.maxWideWidth = grid.maxTileWidth *
+        tileWidthFraction(grid.maxColCount, grid.tileSpacingFraction);
     // Tile-related pixel values for the narrow display.
-    grid.narrowTileValues = tileValuesForGrid(grid.narrowWidth,
-                                              grid.minColCount,
-                                              grid.tileSpacingFraction);
+    grid.narrowTileValues = tileValuesForGrid(
+        grid.narrowWidth, grid.minColCount, grid.tileSpacingFraction);
     // Tile-related pixel values for the minimum narrow display.
-    grid.wideTileValues = tileValuesForGrid(grid.minWideWidth,
-                                            grid.maxColCount,
-                                            grid.tileSpacingFraction);
+    grid.wideTileValues = tileValuesForGrid(
+        grid.minWideWidth, grid.maxColCount, grid.tileSpacingFraction);
   };
 
   TilePage.prototype = {
     __proto__: HTMLDivElement.prototype,
 
     initialize: function() {
       this.className = 'tile-page';
 
       // Div that acts as a custom scrollbar. The scrollbar has to live
       // outside the content div so it doesn't flicker when scrolling (due to
@@ skipping 14 matching lines @@
       // Div that sets the vertical position of the tile grid.
       this.topMargin_ = this.ownerDocument.createElement('div');
       this.topMargin_.className = 'top-margin';
       this.content_.appendChild(this.topMargin_);
 
       // Div that holds the tiles.
       this.tileGrid_ = this.ownerDocument.createElement('div');
       this.tileGrid_.className = 'tile-grid';
       this.tileGrid_.style.minWidth = this.gridValues_.narrowWidth + 'px';
       this.tileGrid_.setAttribute('role', 'menu');
-      this.tileGrid_.setAttribute('aria-label',
-          loadTimeData.getString(
-              'tile_grid_screenreader_accessible_description'));
+      this.tileGrid_.setAttribute(
+          'aria-label', loadTimeData.getString(
+                            'tile_grid_screenreader_accessible_description'));
 
       this.content_.appendChild(this.tileGrid_);
 
       // Ordered list of our tiles.
       this.tileElements_ = this.tileGrid_.getElementsByClassName('tile real');
       // Ordered list of the elements which want to accept keyboard focus. These
       // elements will not be a part of the normal tab order; the tile grid
       // initially gets focused and then these elements can be focused via the
       // arrow keys.
       this.focusableElements_ =
           this.tileGrid_.getElementsByClassName('focusable');
 
       // These are properties used in updateTopMargin.
       this.animatedTopMarginPx_ = 0;
       this.topMarginPx_ = 0;
 
       this.eventTracker = new EventTracker();
       this.eventTracker.add(window, 'resize', this.onResize_.bind(this));
 
-      this.addEventListener('DOMNodeInsertedIntoDocument',
-                            this.onNodeInsertedIntoDocument_);
+      this.addEventListener(
+          'DOMNodeInsertedIntoDocument', this.onNodeInsertedIntoDocument_);
 
       this.content_.addEventListener('scroll', this.onScroll_.bind(this));
 
       this.dragWrapper_ = new cr.ui.DragWrapper(this.tileGrid_, this);
 
       this.addEventListener('cardselected', this.handleCardSelection_);
       this.addEventListener('carddeselected', this.handleCardDeselection_);
       this.addEventListener('focus', this.handleFocus_);
       this.addEventListener('keydown', this.handleKeyDown_);
       this.addEventListener('mousedown', this.handleMouseDown_);
@@ skipping 47 matching lines @@
     /**
      * Removes the tilePage from the DOM and cleans up event handlers.
      *
      * TODO(dbeam): this method now conflicts with HTMLElement#remove(). Rename.
      */
     remove: function() {
       // This checks arguments.length as most remove functions have a boolean
       // |opt_animate| argument, but that's not necesarilly applicable to
       // removing a tilePage. Selecting a different card in an animated way and
       // deleting the card afterward is probably a better choice.
-      assert(typeof arguments[0] != 'boolean',
-             'This function takes no |opt_animate| argument.');
+      assert(
+          typeof arguments[0] != 'boolean',
+          'This function takes no |opt_animate| argument.');
       this.tearDown_();
       this.parentNode.removeChild(this);
     },
 
     /**
      * Cleans up resources that are no longer needed after this TilePage
      * instance is removed from the DOM.
      * @private
      */
     tearDown_: function() {
@@ skipping 136 matching lines @@
       this.updateFocusElement_();
     },
 
     /**
      * Since we are doing custom focus handling, we have to manually
      * set focusability on click (as well as keyboard nav above).
      * @param {Event} e The focus event.
      * @private
      */
     handleMouseDown_: function(e) {
-      var focusable = findAncestorByClass(/** @type {Element} */(e.target),
-                                          'focusable');
+      var focusable =
+          findAncestorByClass(/** @type {Element} */ (e.target), 'focusable');
       if (focusable) {
         this.focusElementIndex_ =
-            Array.prototype.indexOf.call(this.focusableElements_,
-                                         focusable);
+            Array.prototype.indexOf.call(this.focusableElements_, focusable);
         this.updateFocusElement_();
       }
-  },
+    },
 
     /**
      * Handle arrow key focus nav.
      * @param {Event} e The focus event.
      * @private
      */
     handleKeyDown_: function(e) {
       // We only handle up, down, left, right without control keys.
       if (e.metaKey || e.shiftKey || e.altKey || e.ctrlKey)
         return;
 
       // Wrap the given index to |this.focusableElements_|.
       var wrap = function(idx) {
         return (idx + this.focusableElements_.length) %
             this.focusableElements_.length;
       }.bind(this);
 
       switch (e.key) {
         case 'ArrowRight':
         case 'ArrowLeft':
           var direction = e.key == 'ArrowRight' ? 1 : -1;
           this.focusElementIndex_ = wrap(this.focusElementIndex_ + direction);
           break;
         case 'ArrowUp':
         case 'ArrowDown':
           // Look through all focusable elements. Find the first one that is
           // in the same column.
           var direction = e.key == 'ArrowUp' ? -1 : 1;
-          var currentIndex =
-              Array.prototype.indexOf.call(this.focusableElements_,
-                                           this.currentFocusElement_);
+          var currentIndex = Array.prototype.indexOf.call(
+              this.focusableElements_, this.currentFocusElement_);
           var newFocusIdx = wrap(currentIndex + direction);
           var tile = this.currentFocusElement_.parentNode;
           for (;; newFocusIdx = wrap(newFocusIdx + direction)) {
             var newTile = this.focusableElements_[newFocusIdx].parentNode;
             var rowTiles = this.layoutValues_.numRowTiles;
             if ((newTile.index - tile.index) % rowTiles == 0)
               break;
           }
 
           this.focusElementIndex_ = newFocusIdx;
@@ skipping 14 matching lines @@
      * make the focusable element at this.focusElementIndex_ (if any) eligible
      * for tab focus, and the previously-focused element not eligible.
      * @protected
      */
     updateFocusableElement: function() {
       if (this.focusableElements_.length == 0 || !this.selected) {
         this.focusElementIndex_ = -1;
         return;
       }
 
-      this.focusElementIndex_ = Math.min(this.focusableElements_.length - 1,
-                                         this.focusElementIndex_);
+      this.focusElementIndex_ =
+          Math.min(this.focusableElements_.length - 1, this.focusElementIndex_);
       this.focusElementIndex_ = Math.max(0, this.focusElementIndex_);
 
       var newFocusElement = this.focusableElements_[this.focusElementIndex_];
       var lastFocusElement = this.currentFocusElement_;
       if (lastFocusElement && lastFocusElement != newFocusElement)
         lastFocusElement.tabIndex = -1;
 
       newFocusElement.tabIndex = 1;
     },
 
@@ skipping 24 matching lines @@
      * hidden, but call before being shown.
      * @private
      */
     calculateLayoutValues_: function() {
       var grid = this.gridValues_;
       var availableSpace = this.tileGrid_.clientWidth - 2 * MIN_WIDE_MARGIN;
       var wide = availableSpace >= grid.minWideWidth;
       var numRowTiles = wide ? grid.maxColCount : grid.minColCount;
 
       var effectiveGridWidth = wide ?
-          Math.min(Math.max(availableSpace, grid.minWideWidth),
-                   grid.maxWideWidth) :
+          Math.min(
+              Math.max(availableSpace, grid.minWideWidth), grid.maxWideWidth) :
           grid.narrowWidth;
-      var realTileValues = tileValuesForGrid(effectiveGridWidth, numRowTiles,
-                                             grid.tileSpacingFraction);
+      var realTileValues = tileValuesForGrid(
+          effectiveGridWidth, numRowTiles, grid.tileSpacingFraction);
 
       // leftMargin centers the grid within the avaiable space.
       var minMargin = wide ? MIN_WIDE_MARGIN : 0;
-      var leftMargin =
-          Math.max(minMargin,
-                   (this.tileGrid_.clientWidth - effectiveGridWidth) / 2);
+      var leftMargin = Math.max(
+          minMargin, (this.tileGrid_.clientWidth - effectiveGridWidth) / 2);
 
       var rowHeight = this.heightForWidth(realTileValues.tileWidth) +
           realTileValues.interTileSpacing;
 
       this.layoutValues_ = {
         colWidth: realTileValues.offsetX,
         gridWidth: effectiveGridWidth,
         leftMargin: leftMargin,
         numRowTiles: numRowTiles,
         rowHeight: rowHeight,
@@ skipping 42 matching lines @@
       var indexOffset = opt_indexOffset || 0;
       // Add the offset _after_ the modulus division. We might want to show the
       // tile off the side of the grid.
       var col = index % layout.numRowTiles + indexOffset;
       var row = Math.floor(index / layout.numRowTiles);
       // Calculate the final on-screen position for the tile.
       var realX = col * layout.colWidth + layout.leftMargin;
       var realY = row * layout.rowHeight;
 
       // Calculate the portion of the tile's position that should be animated.
-      var animatedTileValues = layout.wide ?
-          grid.wideTileValues : grid.narrowTileValues;
+      var animatedTileValues =
+          layout.wide ? grid.wideTileValues : grid.narrowTileValues;
       // Animate the difference between three-wide and six-wide.
       var animatedLeftMargin = this.getAnimatedLeftMargin_();
       var animatedX = col * animatedTileValues.offsetX + animatedLeftMargin;
       var animatedY = row * (this.heightForWidth(animatedTileValues.tileWidth) +
                              animatedTileValues.interTileSpacing);
 
       var tile = this.tileElements_[index];
       tile.setGridPosition(animatedX, animatedY);
-      tile.firstChild.setBounds(layout.tileWidth,
-                                realX - animatedX,
-                                realY - animatedY);
+      tile.firstChild.setBounds(
+          layout.tileWidth, realX - animatedX, realY - animatedY);
 
       // This code calculates whether the tile needs to show a clone of itself
       // wrapped around the other side of the tile grid.
       var offTheRight = col == layout.numRowTiles ||
           (col == layout.numRowTiles - 1 && tile.hasDoppleganger());
       var offTheLeft = col == -1 || (col == 0 && tile.hasDoppleganger());
       if (this.isCurrentDragTarget && (offTheRight || offTheLeft)) {
         var sign = offTheRight ? 1 : -1;
-        tile.showDoppleganger(-layout.numRowTiles * layout.colWidth * sign,
-                              layout.rowHeight * sign);
+        tile.showDoppleganger(
+            -layout.numRowTiles * layout.colWidth * sign,
+            layout.rowHeight * sign);
       } else {
         tile.clearDoppleganger();
       }
 
       if (index == this.tileElements_.length - 1) {
         this.tileGrid_.style.height = (realY + layout.rowHeight) + 'px';
         this.queueUpdateScrollbars_();
       }
     },
 
     /**
      * Gets the index of the tile that should occupy coordinate (x, y). Note
      * that this function doesn't care where the tiles actually are, and will
      * return an index even for the space between two tiles. This function is
      * effectively the inverse of |positionTile_|.
      * @param {number} x The x coordinate, in pixels, relative to the left of
      *     |this|.
      * @param {number} y The y coordinate, in pixels, relative to the top of
      *     |this|.
      * @return {number}
      * @private
      */
     getWouldBeIndexForPoint_: function(x, y) {
       var grid = this.gridValues_;
       var layout = this.layoutValues_;
 
       var gridClientRect = this.tileGrid_.getBoundingClientRect();
-      var col = Math.floor((x - gridClientRect.left - layout.leftMargin) /
-                           layout.colWidth);
+      var col = Math.floor(
+          (x - gridClientRect.left - layout.leftMargin) / layout.colWidth);
       if (col < 0 || col >= layout.numRowTiles)
         return -1;
 
       if (isRTL())
         col = layout.numRowTiles - 1 - col;
 
       var row = Math.floor((y - gridClientRect.top) / layout.rowHeight);
       return row * layout.numRowTiles + col;
     },
 
@@ skipping 24 matching lines @@
      * @private
      */
     updateMask_: function() {
       if (!this.isCurrentDragTarget) {
         this.tileGrid_.style.WebkitMaskBoxImage = '';
         return;
       }
 
       var leftMargin = this.layoutValues_.leftMargin;
       // The fade distance is the space between tiles.
-      var fadeDistance = (this.gridValues_.tileSpacingFraction *
-          this.layoutValues_.tileWidth);
+      var fadeDistance =
+          (this.gridValues_.tileSpacingFraction * this.layoutValues_.tileWidth);
       fadeDistance = Math.min(leftMargin, fadeDistance);
       // On Skia we don't use any fade because it works very poorly. See
       // http://crbug.com/99373
       if (!cr.isMac)
         fadeDistance = 1;
-      var gradient =
-          '-webkit-linear-gradient(left,' +
-              'transparent, ' +
-              'transparent ' + (leftMargin - fadeDistance) + 'px, ' +
-              'black ' + leftMargin + 'px, ' +
-              'black ' + (this.tileGrid_.clientWidth - leftMargin) + 'px, ' +
-              'transparent ' + (this.tileGrid_.clientWidth - leftMargin +
-                                fadeDistance) + 'px, ' +
-              'transparent)';
+      var gradient = '-webkit-linear-gradient(left,' +
+          'transparent, ' +
+          'transparent ' + (leftMargin - fadeDistance) + 'px, ' +
+          'black ' + leftMargin + 'px, ' +
+          'black ' + (this.tileGrid_.clientWidth - leftMargin) + 'px, ' +
+          'transparent ' +
+          (this.tileGrid_.clientWidth - leftMargin + fadeDistance) + 'px, ' +
+          'transparent)';
       this.tileGrid_.style.WebkitMaskBoxImage = gradient;
     },
 
     updateTopMargin_: function() {
       var layout = this.layoutValues_;
 
       // The top margin is set so that the vertical midpoint of the grid will
       // be 1/3 down the page.
       var numTiles = this.tileCount +
           (this.isCurrentDragTarget && !this.withinPageDrag_ ? 1 : 0);
@@ skipping 91 matching lines @@
      * Queues an update on the custom scrollbar. Used for two reasons: first,
      * coalescing of multiple updates, and second, because action like
      * repositioning a tile can require a delay before they affect values
      * like clientHeight.
      * @private
      */
     queueUpdateScrollbars_: function() {
       if (this.scrollbarUpdate_)
         return;
 
-      this.scrollbarUpdate_ = window.setTimeout(
-          this.doUpdateScrollbars_.bind(this), 0);
+      this.scrollbarUpdate_ =
+          window.setTimeout(this.doUpdateScrollbars_.bind(this), 0);
     },
 
     /**
      * Does the work of calculating the visibility, height and position of the
      * scrollbar thumb (there is no track or buttons).
      * @private
      */
     doUpdateScrollbars_: function() {
       this.scrollbarUpdate_ = 0;
 
       var content = this.content_;
 
       // Adjust scroll-height to account for possible header-bar.
       var adjustedScrollHeight = content.scrollHeight - content.offsetTop;
 
       if (adjustedScrollHeight <= content.clientHeight) {
         this.scrollbar_.hidden = true;
         return;
       } else {
         this.scrollbar_.hidden = false;
       }
 
       var thumbTop = content.offsetTop +
           content.scrollTop / adjustedScrollHeight * content.clientHeight;
-      var thumbHeight = content.clientHeight / adjustedScrollHeight *
-          this.clientHeight;
+      var thumbHeight =
+          content.clientHeight / adjustedScrollHeight * this.clientHeight;
 
       this.scrollbar_.style.top = thumbTop + 'px';
       this.scrollbar_.style.height = thumbHeight + 'px';
       this.firePageLayoutEvent_();
     },
 
     /**
      * Get the height for a tile of a certain width. Override this function to
      * get non-square tiles.
      * @param {number} width The pixel width of a tile.
@@ skipping 14 matching lines @@
       this.cleanupDrag();
     },
 
     /** @override */
     doDragEnter: function(e) {
       // Applies the mask so doppleganger tiles disappear into the fog.
       this.updateMask_();
 
       this.classList.add('animating-tile-page');
       this.withinPageDrag_ = this.contains(currentlyDraggingTile);
-      this.dragItemIndex_ = this.withinPageDrag_ ?
-          currentlyDraggingTile.index : this.tileElements_.length;
+      this.dragItemIndex_ = this.withinPageDrag_ ? currentlyDraggingTile.index :
+                                                   this.tileElements_.length;
       this.currentDropIndex_ = this.dragItemIndex_;
 
       // The new tile may change the number of rows, hence the top margin
       // will change.
       if (!this.withinPageDrag_)
         this.updateTopMargin_();
 
       this.doDragOver(e);
     },
 
     /** @override */
     doDragOver: function(e) {
       e.preventDefault();
 
       this.setDropEffect(e.dataTransfer);
       var newDragIndex = this.getWouldBeIndexForPoint_(e.pageX, e.pageY);
       if (newDragIndex < 0 || newDragIndex >= this.tileElements_.length)
         newDragIndex = this.dragItemIndex_;
       this.updateDropIndicator_(newDragIndex);
     },
 
     /** @override */
     doDrop: function(e) {
       e.stopPropagation();
       e.preventDefault();
 
       var index = this.currentDropIndex_;
       // Only change data if this was not a 'null drag'.
       if (!((index == this.dragItemIndex_) && this.withinPageDrag_)) {
-        var adjustedIndex = this.currentDropIndex_ +
-            (index > this.dragItemIndex_ ? 1 : 0);
+        var adjustedIndex =
+            this.currentDropIndex_ + (index > this.dragItemIndex_ ? 1 : 0);
         if (this.withinPageDrag_) {
           this.tileGrid_.insertBefore(
-              currentlyDraggingTile,
-              this.tileElements_[adjustedIndex]);
+              currentlyDraggingTile, this.tileElements_[adjustedIndex]);
           this.tileMoved(currentlyDraggingTile, this.dragItemIndex_);
         } else {
-          var originalPage = currentlyDraggingTile ?
-              currentlyDraggingTile.tilePage : null;
+          var originalPage =
+              currentlyDraggingTile ? currentlyDraggingTile.tilePage : null;
           this.addDragData(e.dataTransfer, adjustedIndex);
           if (originalPage)
             originalPage.cleanupDrag();
         }
 
         // Dropping the icon may cause topMargin to change, but changing it
         // now would cause everything to move (annoying), so we leave it
         // alone. The top margin will be re-calculated next time the window is
         // resized or the page is selected.
       }
@@ skipping 82 matching lines @@
     addDragData: function(dataTransfer, index) {
       assertNotReached();
     },
 
     /**
      * Called when a tile has been moved (via dragging). Override this to make
      * backend updates.
      * @param {Node} draggedTile The tile that was dropped.
      * @param {number} prevIndex The previous index of the tile.
      */
-    tileMoved: function(draggedTile, prevIndex) {
-    },
+    tileMoved: function(draggedTile, prevIndex) {},
 
     /**
      * Sets the drop effect on |dataTransfer| to the desired value (e.g.
      * 'copy').
      * @param {Object} dataTransfer The drag event dataTransfer object.
      */
     setDropEffect: function(dataTransfer) {
       assertNotReached();
     },
   };
 
   return {
     getCurrentlyDraggingTile: getCurrentlyDraggingTile,
     setCurrentDropEffect: setCurrentDropEffect,
     // Not used outside, just for usage in JSDoc inside this file.
     Tile: Tile,
     TilePage: TilePage,
   };
 });