Compile chrome://settings, part 7. 33 errors left

chrome/browser/resources/options/cookies_list.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('options', function() {
   /** @const */ var DeletableItemList = options.DeletableItemList;
   /** @const */ var DeletableItem = options.DeletableItem;
   /** @const */ var ArrayDataModel = cr.ui.ArrayDataModel;
   /** @const */ var ListSingleSelectionModel = cr.ui.ListSingleSelectionModel;
 
@@ skipping 48 matching lines @@
     if (height && height.substr(-2) == 'px')
       return parseInt(height.substr(0, height.length - 2), 10);
     return item.getBoundingClientRect().height;
   }
 
   /**
    * Create tree nodes for the objects in the data array, and insert them all
    * into the given list using its @{code splice} method at the given index.
    * @param {Array.<Object>} data The data objects for the nodes to add.
    * @param {number} start The index at which to start inserting the nodes.
-   * @return {Array.<CookieTreeNode>} An array of CookieTreeNodes added.
+   * @return {Array.<options.CookieTreeNode>} An array of CookieTreeNodes added.
    */
   function spliceTreeNodes(data, start, list) {
     var nodes = data.map(function(x) { return new CookieTreeNode(x); });
     // Insert [start, 0] at the beginning of the array of nodes, making it
     // into the arguments we want to pass to @{code list.splice} below.
     nodes.splice(0, 0, start, 0);
     list.splice.apply(list, nodes);
     // Remove the [start, 0] prefix and return the array of nodes.
     nodes.splice(0, 2);
     return nodes;
@@ skipping 22 matching lines @@
    * Creates a new list item for sites data. Note that these are created and
    * destroyed lazily as they scroll into and out of view, so they must be
    * stateless. We cache the expanded item in @{code CookiesList} though, so it
    * can keep state. (Mostly just which item is selected.)
    * @param {Object} origin Data used to create a cookie list item.
    * @param {options.CookiesList} list The list that will contain this item.
    * @constructor
    * @extends {options.DeletableItem}
    */
   function CookieListItem(origin, list) {
-    var listItem = new DeletableItem(null);
+    var listItem = new DeletableItem();
     listItem.__proto__ = CookieListItem.prototype;
 
     listItem.origin = origin;
     listItem.list = list;
     listItem.decorate();
 
     // This hooks up updateOrigin() to the list item, makes the top-level
     // tree nodes (i.e., origins) register their IDs in parentLookup, and
     // causes them to request their children if they have none. Note that we
     // have special logic in the setter for the parent property to make sure
@@ skipping 185 matching lines @@
       this.selectedIndex_ = -1;
       this.itemList_ = [];
       if (this.origin)
         this.origin.createItems(this);
       this.itemsChild.appendChild(this.infoChild);
       this.enableAnimation_();
     },
 
     /**
      * Append a new cookie node "bubble" to this list item.
-     * @param {CookieTreeNode} node The cookie node to add a bubble for.
+     * @param {options.CookieTreeNode} node The cookie node to add a bubble for.
      * @param {Element} div The DOM element for the bubble itself.
      * @return {number} The index the bubble was added at.
      */
     appendItem: function(node, div) {
       this.itemList_.push({node: node, div: div});
       this.itemsChild.appendChild(div);
       return this.itemList_.length - 1;
     },
 
     /**
@@ skipping 172 matching lines @@
           apps.forEach(function(appInfo) {
             info.appsProtectingThis[appInfo.id] = appInfo;
           });
         }
       }
     },
 
     /**
      * Create the cookie "bubbles" for this node, recursing into children
      * if there are any. Append the cookie bubbles to @{code item}.
-     * @param {CookieListItem} item The cookie list item to create items in.
+     * @param {options.CookieListItem} item The cookie list item to create items
+     *     in.
      */
     createItems: function(item) {
       if (this.children.length > 0) {
         for (var i = 0; i < this.children.length; ++i)
           this.children[i].createItems(item);
         return;
       }
 
       if (!this.data || this.data.hasChildren)
         return;
@@ skipping 52 matching lines @@
 
       while (element.childNodes.length > 1)
         element.removeChild(element.firstChild);
 
       if (table)
         element.insertBefore(table, element.firstChild);
     },
 
     /**
      * The parent of this cookie tree node.
-     * @type {?CookieTreeNode|CookieListItem}
+     * @type {?(options.CookieTreeNode|options.CookieListItem)}
      */
     get parent() {
       // See below for an explanation of this special case.
       if (typeof this.parent_ == 'number')
         return this.list_.getListItemByIndex(this.parent_);
       return this.parent_;
     },
     set parent(parent) {
       if (parent == this.parent)
         return;
@@ skipping 194 matching lines @@
       }
       if (pe.newValue != -1) {
         var listItem = this.getListItemByIndex(pe.newValue);
         if (listItem && listItem.selected)
           listItem.expanded = true;
       }
     },
 
     /**
      * The currently expanded item. Used by CookieListItem above.
-     * @type {?CookieListItem}
+     * @type {?options.CookieListItem}
      */
     expandedItem: null,
 
     // from cr.ui.List
-    /** @override */
+    /**
+     * @override
+     * @param {Object} data
+     */
     createItem: function(data) {
       // We use the cached expanded item in order to allow it to maintain some
       // state (like its fixed height, and which bubble is selected).
       if (this.expandedItem && this.expandedItem.origin == data)
         return this.expandedItem;
       return new CookieListItem(data, this);
     },
 
     // from options.DeletableItemList
     /** @override */
@@ skipping 101 matching lines @@
         return;
 
       parent.startBatchUpdates();
       parent.clear();
       this.addByParent_(parent, 0, children);
       parent.endBatchUpdates();
     },
   };
 
   return {
-    CookiesList: CookiesList
+    CookiesList: CookiesList,
+    CookieListItem: CookieListItem,
+    CookieTreeNode: CookieTreeNode,
   };
 });