Typecheck chrome://bookmarks using Closure Compiler

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;
@@ skipping 29 matching lines @@
 
   /**
     * 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}
+    * @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' :
@@ skipping 126 matching lines @@
       return dragData && dragData.elements.some(function(node) {
         var dragFolder = bmm.treeLookup[node.id];
         var dragFolderNode = dragFolder && dragFolder.bookmarkNode;
         return dragFolderNode && bmm.contains(dragFolderNode, bookmarkNode);
       });
     }
   };
 
   /**
    * External function to select folders or bookmarks after a drop action.
-   * @type {function}
+   * @type {?Function}
    */
   var selectItemsAfterUserAction = null;
 
   function getBookmarkElement(el) {
     while (el && !el.bookmarkNode) {
       el = el.parentNode;
     }
     return el;
   }
 
   // If we are over the list and the list is showing search result, we cannot
   // drop.
   function isOverSearch(overElement) {
-    return list.isSearch() && list.contains(overElement);
+    return bmm.list.isSearch() && bmm.list.contains(overElement);
   }
 
   /**
    * Determines the valid drop positions for the given target element.
    * @param {!HTMLElement} overElement The element that we are currently
    *     dragging over.
    * @return {DropPosition} An bit field enumeration of valid drop locations.
    */
   function calculateValidDropTargets(overElement) {
     // Don't allow dropping if there is an ephemeral item being edited.
-    if (list.hasEphemeral())
+    if (bmm.list.hasEphemeral())
       return DropPosition.NONE;
 
     if (!dragInfo.isDragValid() || isOverSearch(overElement))
       return DropPosition.NONE;
 
     if (dragInfo.isSameProfile() &&
         (dragInfo.isDraggingBookmark(overElement.bookmarkNode.id) ||
          dragInfo.isDraggingFolderToDescendant(overElement.bookmarkNode))) {
       return DropPosition.NONE;
     }
@@ skipping 62 matching lines @@
     if (!bmm.isFolder(overElement.bookmarkNode))
       return false;
 
     if (!dragInfo.isSameProfile())
       return true;
 
     if (overElement instanceof BookmarkList) {
       // We are trying to drop an item past the last item. This is
       // only allowed if dragged item is different from the last item
       // in the list.
-      var listItems = list.items;
+      var listItems = bmm.list.items;
       var len = listItems.length;
       if (!len || !dragInfo.isDraggingBookmark(listItems[len - 1].bookmarkId))
         return true;
     }
 
     return !dragInfo.isDraggingChildBookmark(overElement.bookmarkNode.id);
   }
 
   /**
    * Callback for the dragstart event.
@@ skipping 10 matching lines @@
       draggedNodes = target.parentNode.selectedItems;
     } else if (target instanceof TreeItem) {
       draggedNodes.push(target.bookmarkNode);
     }
 
     // We manage starting the drag by using the extension API.
     e.preventDefault();
 
     // Do not allow dragging if there is an ephemeral item being edited at the
     // moment.
-    if (list.hasEphemeral())
+    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';
 
       chrome.bookmarkManagerPrivate.startDrag(draggedNodes.map(function(node) {
         return node.id;
@@ skipping 17 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 == list ? 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 58 matching lines @@
         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 = list;
+      dropInfoResult.selectTarget = bmm.list;
     } else if (overElement instanceof BookmarkList) {
       dropInfoResult.relatedIndex = overElement.dataModel.length - 1;
-      dropInfoResult.selectTarget = list;
+      dropInfoResult.selectTarget = bmm.list;
     } else {
       // Tree
       dropInfoResult.relatedIndex = relatedNode.index;
-      dropInfoResult.selectTarget = tree;
+      dropInfoResult.selectTarget = bmm.tree;
       dropInfoResult.selectedTreeId =
-          tree.selectedItem ? tree.selectedItem.bookmarkId : null;
+          bmm.tree.selectedItem ? bmm.tree.selectedItem.bookmarkId : null;
     }
 
     if (dropPos == DropPosition.ABOVE)
       dropInfoResult.index = dropInfoResult.relatedIndex;
     else if (dropPos == DropPosition.BELOW)
       dropInfoResult.index = dropInfoResult.relatedIndex + 1;
 
     return dropInfoResult;
   }
 
@@ skipping 28 matching lines @@
       currentTouchTarget = null;
   }
 
   function clearDragData() {
     dragInfo.clearDragData();
     dropDestination = null;
   }
 
   function init(selectItemsAfterUserActionFunction) {
     function deferredClearData() {
-      setTimeout(clearDragData);
+      setTimeout(clearDragData, 0);
     }
 
     selectItemsAfterUserAction = selectItemsAfterUserActionFunction;
 
     document.addEventListener('dragstart', handleDragStart);
     document.addEventListener('dragenter', handleDragEnter);
     document.addEventListener('dragover', handleDragOver);
     document.addEventListener('dragleave', handleDragLeave);
     document.addEventListener('drop', handleDrop);
     document.addEventListener('dragend', deferredClearData);
     document.addEventListener('mouseup', deferredClearData);
     document.addEventListener('mousedown', clearCurrentTouchTarget);
     document.addEventListener('touchcancel', clearCurrentTouchTarget);
     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};
 });