Typecheck chrome://bookmarks using Closure Compiler

chrome/browser/resources/bookmark_manager/js/bmm/bookmark_tree.js

 // Copyright (c) 2011 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('bmm', function() {
   /**
    * The id of the bookmark root.
    * @type {string}
    * @const
    */
   var ROOT_ID = '0';
 
   /** @const */ var Tree = cr.ui.Tree;
   /** @const */ var TreeItem = cr.ui.TreeItem;
+  /** @const */ var localStorage = window.localStorage;
 
   var treeLookup = {};
-  var tree;
 
   // Manager for persisting the expanded state.
-  var expandedManager = {
+  var expandedManager = /** @type {EventListener} */({
     /**
      * A map of the collapsed IDs.
      * @type {Object}
      */
     map: 'bookmarkTreeState' in localStorage ?
-        JSON.parse(localStorage['bookmarkTreeState']) : {},
+        /** @type {Object} */(JSON.parse(localStorage['bookmarkTreeState'])) :
+        {},
 
     /**
      * Set the collapsed state for an ID.
-     * @param {string} The bookmark ID of the tree item that was expanded or
+     * @param {string} id The bookmark ID of the tree item that was expanded or
      *     collapsed.
      * @param {boolean} expanded Whether the tree item was expanded.
      */
     set: function(id, expanded) {
       if (expanded)
         delete this.map[id];
       else
         this.map[id] = 1;
 
       this.save();
@@ skipping 34 matching lines @@
      * Saves the expanded state to the localStorage.
      */
     save: function() {
       clearTimeout(this.timer);
       var map = this.map;
       // Save in a timeout so that we can coalesce multiple changes.
       this.timer = setTimeout(function() {
         localStorage['bookmarkTreeState'] = JSON.stringify(map);
       }, 100);
     }
-  };
+  });
 
   // Clean up once per session but wait until things settle down a bit.
   setTimeout(expandedManager.cleanUp.bind(expandedManager), 1e4);
 
   /**
    * Creates a new tree item for a bookmark node.
    * @param {!Object} bookmarkNode The bookmark node.
    * @constructor
    * @extends {TreeItem}
    */
@@ skipping 27 matching lines @@
    *
    * Since the bookmark tree only contains folders the index we get from certain
    * callbacks is not very useful so we therefore have this async call which
    * gets the children of the parent and adds the tree item at the desired
    * index.
    *
    * This also exoands the parent so that newly added children are revealed.
    *
    * @param {!cr.ui.TreeItem} parent The parent tree item.
    * @param {!cr.ui.TreeItem} treeItem The tree item to add.
-   * @param {Function=} f A function which gets called after the item has been
-   *     added at the right index.
+   * @param {Function=} opt_f A function which gets called after the item has
+   *     been added at the right index.
    */
   function addTreeItem(parent, treeItem, opt_f) {
     chrome.bookmarks.getChildren(parent.bookmarkNode.id, function(children) {
-      var index = children.filter(bmm.isFolder).map(function(item) {
+      var isFolder = /**
+                      * @type {function (BookmarkTreeNode, number,
+                      *                  Array.<(BookmarkTreeNode)>)}
+                      */(bmm.isFolder);
+      var index = children.filter(isFolder).map(function(item) {
         return item.id;
       }).indexOf(treeItem.bookmarkNode.id);
       parent.addAt(treeItem, index);
       parent.expanded = true;
       if (opt_f)
         opt_f();
     });
   }
 
 
   /**
    * Creates a new bookmark list.
    * @param {Object=} opt_propertyBag Optional properties.
    * @constructor
-   * @extends {HTMLButtonElement}
+   * @extends {cr.ui.Tree}
    */
   var BookmarkTree = cr.ui.define('tree');
 
   BookmarkTree.prototype = {
     __proto__: Tree.prototype,
 
     decorate: function() {
       Tree.prototype.decorate.call(this);
       this.addEventListener('expand', expandedManager);
       this.addEventListener('collapse', expandedManager);
 
       bmm.tree = this;
     },
 
     handleBookmarkChanged: function(id, changeInfo) {
       var treeItem = treeLookup[id];
       if (treeItem)
         treeItem.label = treeItem.bookmarkNode.title = changeInfo.title;
     },
 
+    /**
+     * @param {string} id
+     * @param {ReorderInfo} reorderInfo
+     */
     handleChildrenReordered: function(id, reorderInfo) {
       var parentItem = treeLookup[id];
       // The tree only contains folders.
       var dirIds = reorderInfo.childIds.filter(function(id) {
         return id in treeLookup;
       }).forEach(function(id, i) {
         parentItem.addAt(treeLookup[id], i);
       });
     },
 
     handleCreated: function(id, bookmarkNode) {
       if (bmm.isFolder(bookmarkNode)) {
         var parentItem = treeLookup[bookmarkNode.parentId];
         var newItem = new BookmarkTreeItem(bookmarkNode);
         addTreeItem(parentItem, newItem);
       }
     },
 
+    /**
+     * @param {string} id
+     * @param {MoveInfo} moveInfo
+     */
     handleMoved: function(id, moveInfo) {
       var treeItem = treeLookup[id];
       if (treeItem) {
         var oldParentItem = treeLookup[moveInfo.oldParentId];
         oldParentItem.remove(treeItem);
         var newParentItem = treeLookup[moveInfo.parentId];
         // The tree only shows folders so the index is not the index we want. We
         // therefore get the children need to adjust the index.
         addTreeItem(newParentItem, treeItem);
       }
@@ skipping 52 matching lines @@
        *     nodes to be added.
        * @return {boolean} Whether any directories where added.
        */
       function buildTreeItems(parentTreeItem, bookmarkNodes) {
         var hasDirectories = false;
         for (var i = 0, bookmarkNode; bookmarkNode = bookmarkNodes[i]; i++) {
           if (bmm.isFolder(bookmarkNode)) {
             hasDirectories = true;
             var item = new BookmarkTreeItem(bookmarkNode);
             parentTreeItem.add(item);
-            var anyChildren = buildTreeItems(item, bookmarkNode.children);
+            var children = assert(bookmarkNode.children);
+            var anyChildren = buildTreeItems(item, children);
             item.expanded = anyChildren && expandedManager.get(bookmarkNode.id);
           }
         }
         return hasDirectories;
       }
 
       var self = this;
       chrome.bookmarkManagerPrivate.getSubtree('', true, function(root) {
         self.clear();
         buildTreeItems(self, root[0].children);
@@ skipping 18 matching lines @@
       Tree.prototype.remove.call(this, child);
       if (child.bookmarkNode)
         delete treeLookup[child.bookmarkNode.id];
     }
   };
 
   return {
     BookmarkTree: BookmarkTree,
     BookmarkTreeItem: BookmarkTreeItem,
     treeLookup: treeLookup,
-    tree: tree,
+    tree: /** @type {Element} */(null),  // Set when decorated.
     ROOT_ID: ROOT_ID
   };
 });