Compile chrome://settings, part 3: 167 proper errors left

chrome/browser/resources/options/chromeos/bluetooth_device_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.
 
+/**
+ * @typedef {{name: string,
+ *            address: string,
+ *            paired: boolean,
+ *            connected: boolean,
+ *            connecting: boolean,
+ *            connectable: boolean,
+ *            pairing: (string|undefined),
+ *            passkey: (number|undefined),
+ *            pincode: (string|undefined),
+ *            entered: (number|undefined)}}
+ */
+var BluetoothDevice;
+
 cr.define('options.system.bluetooth', function() {
   /** @const */ var ArrayDataModel = cr.ui.ArrayDataModel;
   /** @const */ var DeletableItem = options.DeletableItem;
   /** @const */ var DeletableItemList = options.DeletableItemList;
   /** @const */ var ListSingleSelectionModel = cr.ui.ListSingleSelectionModel;
 
   /**
    * Bluetooth settings constants.
    */
   function Constants() {}
 
   /**
    * Creates a new bluetooth list item.
-   * @param {{name: string,
-   *          address: string,
-   *          paired: boolean,
-   *          connected: boolean,
-   *          connecting: boolean,
-   *          connectable: boolean,
-   *          pairing: (string|undefined),
-   *          passkey: (number|undefined),
-   *          pincode: (string|undefined),
-   *          entered: (number|undefined)}} device
-   *    Description of the Bluetooth device.
+   * @param {BluetoothDevice} device Description of the Bluetooth device.
    * @constructor
    * @extends {options.DeletableItem}
    */
   function BluetoothListItem(device) {
     var el = cr.doc.createElement('div');
     el.__proto__ = BluetoothListItem.prototype;
     el.data = {};
     for (var key in device)
       el.data[key] = device[key];
     el.decorate();
     // Only show the close button for paired devices, but not for connecting
     // devices.
     el.deletable = device.paired && !device.connecting;
     return el;
   }
 
   BluetoothListItem.prototype = {
     __proto__: DeletableItem.prototype,
 
     /**
      * Description of the Bluetooth device.
-     * @type {{name: string,
-     *         address: string,
-     *         paired: boolean,
-     *         connected: boolean,
-     *         connecting: boolean,
-     *         connectable: boolean,
-     *         pairing: string|undefined,
-     *         passkey: number|undefined,
-     *         pincode: string|undefined,
-     *         entered: number|undefined}}
+     * @type {?BluetoothDevice}
      */
     data: null,
 
     /** @override */
     decorate: function() {
       DeletableItem.prototype.decorate.call(this);
       var label = this.ownerDocument.createElement('div');
       label.className = 'bluetooth-device-label';
       this.classList.add('bluetooth-device');
       // There are four kinds of devices we want to distinguish:
@@ skipping 64 matching lines @@
     /**
      * Adds a bluetooth device to the list of available devices. A check is
      * made to see if the device is already in the list, in which case the
      * existing device is updated.
      * @param {{name: string,
      *          address: string,
      *          paired: boolean,
      *          connected: boolean,
      *          connecting: boolean,
      *          connectable: boolean,
-     *          pairing: string|undefined,
-     *          passkey: number|undefined,
-     *          pincode: string|undefined,
-     *          entered: number|undefined}} device
+     *          pairing: (string|undefined),
+     *          passkey: (number|undefined),
+     *          pincode: (string|undefined),
+     *          entered: (number|undefined)}} device
      *     Description of the bluetooth device.
      * @return {boolean} True if the devies was successfully added or updated.
      */
     appendDevice: function(device) {
       var selectedDevice = this.getSelectedDevice_();
       var index = this.find(device.address);
       if (index == undefined) {
         this.dataModel.push(device);
         this.redraw();
       } else {
@@ skipping 19 matching lines @@
           this.getSelectedDevice_();
       this.invalidate();
       this.redraw();
       if (selectedDevice)
         this.setSelectedDevice_(selectedDevice);
     },
 
     /**
      * Retrieves the address of the selected device, or null if no device is
      * selected.
-     * @return {?string} Address of selected device or null.
+     * @return {(string|undefined)} Address of selected device or null.
      * @private
      */
     getSelectedDevice_: function() {
       var selection = this.selectedItem;
       if (selection)
         return selection.address;
-      return null;
+      return undefined;
     },
 
     /**
      * Selects the device with the matching address.
      * @param {string} address The unique address of the device.
      * @private
      */
     setSelectedDevice_: function(address) {
       var index = this.find(address);
       if (index != undefined)
@@ skipping 17 matching lines @@
      */
     find: function(address) {
       var size = this.dataModel.length;
       for (var i = 0; i < size; i++) {
         var entry = this.dataModel.item(i);
         if (entry.address == address)
           return i;
       }
     },
 
-    /** @override */
+    /**
+     * @override
+     * @param {BluetoothDevice} entry
+     */
     createItem: function(entry) {
       return new BluetoothListItem(entry);
     },
 
     /**
      * Overrides the default implementation, which is used to compute the
      * size of an element in the list.  The default implementation relies
      * on adding a placeholder item to the list and fetching its size and
      * position. This strategy does not work if an item is added to the list
      * while it is hidden, as the computed metrics will all be zero in that
      * case.
      * @return {{height: number, marginTop: number, marginBottom: number,
      *     width: number, marginLeft: number, marginRight: number}}
      *     The height and width of the item, taking margins into account,
      *     and the margins themselves.
      */
     measureItem: function() {
       return {
         height: this.itemHeight_,
         marginTop: 0,
-        marginBotton: 0,
+        marginBottom: 0,
         width: this.itemWidth_,
         marginLeft: 0,
         marginRight: 0
       };
     },
 
     /**
      * Override the default implementation to return a predetermined size,
      * which in turns allows proper layout of items even if the list is hidden.
      * @return {{height: number, width: number}} Dimensions of a single item in
      *     the list of bluetooth device.
      * @private
      */
     getDefaultItemSize_: function() {
       return {
         height: this.itemHeight_,
         width: this.itemWidth_
       };
     },
 
     /**
      * Override base implementation of handleClick_, which unconditionally
      * removes the item.  In this case, removal of the element is deferred
      * pending confirmation from the Bluetooth adapter.
      * @param {Event} e The click event object.
      * @private
      */
     handleClick_: function(e) {

[Dan Beam, 2014/09/11 05:26:12]

this is overriding a @private member in its base class :(, should probably make
protected or do something different here

[Vitaly Pavlenko, 2014/09/11 21:12:31]

Done.

       if (this.disabled)
         return;
 
-      var target = e.target;
+      var target = /** @type {HTMLElement} */(e.target);

[Dan Beam, 2014/09/11 05:26:12]

generally this is right because of where the base class attaches the listener

[Vitaly Pavlenko, 2014/09/11 21:12:31]

Yes, I think it's right on specific methods like |handleClick|, where we can go
and check that the listener is attached to the element and cannot be fired on
Document/Window.

       if (!target.classList.contains('row-delete-button'))
         return;
 
       var item = this.getListItemAncestor(target);
       var selected = this.selectionModel.selectedIndex;
       var index = this.getIndexOfListItem(item);
       if (item && item.deletable) {
         if (selected != index)
           this.setSelectedDevice_(item.data.address);
         // Device is busy until we hear back from the Bluetooth adapter.
@@ skipping 42 matching lines @@
 
   cr.defineProperty(BluetoothListItem, 'notconnectable',
       cr.PropertyKind.BOOL_ATTR);
 
   return {
     BluetoothListItem: BluetoothListItem,
     BluetoothDeviceList: BluetoothDeviceList,
     Constants: Constants
   };
 });