Revert of Revert "Typecheck JS files for chrome://extensions"

chrome/browser/resources/extensions/extension_loader.js

 // Copyright 2014 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('extensions', function() {
   'use strict';
 
   /**
    * Construct an ExtensionLoadError around the given |div|.
    * @param {HTMLDivElement} div The HTML div for the extension load error.
    * @constructor
+   * @extends {HTMLDivElement}
    */
   function ExtensionLoadError(div) {
     div.__proto__ = ExtensionLoadError.prototype;
     div.init();
     return div;
   }
 
   /**
    * Construct a Failure.
    * @param {string} filePath The path to the unpacked extension.
    * @param {string} error The reason the extension failed to load.
-   * @param {Object} manifest An object with three strings: beforeHighlight,
-   *     afterHighlight, and highlight. These represent three portions of the
-   *     file's content to display - the portion which is most relevant and
-   *     should be emphasized (highlight), and the parts both before and after
-   *     this portion. These may be empty.
+   * @param {ExtensionHighlight} manifest Three 'highlight' strings in
+   *     |manifest| represent three portions of the file's content to display -
+   *     the portion which is most relevant and should be emphasized
+   *     (highlight), and the parts both before and after this portion. These
+   *     may be empty.
    * @param {HTMLLIElement} listElement The HTML element used for displaying the
    *     failure path for the additional failures UI.
    * @constructor
+   * @extends {HTMLDivElement}
    */
   function Failure(filePath, error, manifest, listElement) {
     this.path = filePath;
     this.error = error;
     this.manifest = manifest;
     this.listElement = listElement;
   }
 
   ExtensionLoadError.prototype = {
     __proto__: HTMLDivElement.prototype,
 
     /**
      * Initialize the ExtensionLoadError div.
      */
     init: function() {
       /**
        * The element which displays the path of the extension.
-       * @type {HTMLSpanElement}
+       * @type {HTMLElement}
        * @private
        */
-      this.path_ = this.querySelector('#extension-load-error-path');
+      this.path_ = /** @type {HTMLElement} */(
+          this.querySelector('#extension-load-error-path'));
 
       /**
        * The element which displays the reason the extension failed to load.
-       * @type {HTMLSpanElement}
+       * @type {HTMLElement}
        * @private
        */
-      this.reason_ = this.querySelector('#extension-load-error-reason');
+      this.reason_ = /** @type {HTMLElement} */(
+          this.querySelector('#extension-load-error-reason'));
 
       /**
        * The element which displays the manifest code.
-       * @type {ExtensionCode}
+       * @type {extensions.ExtensionCode}
        * @private
        */
       this.manifest_ = new extensions.ExtensionCode(
           this.querySelector('#extension-load-error-manifest'));
 
       /**
        * The element which displays information about additional errors.
-       * @type {HTMLULElement}
+       * @type {HTMLElement}
        * @private
        */
-      this.additional_ = this.querySelector('#extension-load-error-additional');
+      this.additional_ = /** @type {HTMLUListElement} */(
+          this.querySelector('#extension-load-error-additional'));
       this.additional_.list = this.additional_.getElementsByTagName('ul')[0];
 
       /**
        * An array of Failures for keeping track of multiple active failures.
        * @type {Array.<Failure>}
        * @private
        */
       this.failures_ = [];
 
       this.querySelector('#extension-load-error-retry-button').addEventListener(
@@ skipping 16 matching lines @@
      * failure, display the additional failures element.
      * @param {Array.<Object>} failures Array of failures containing paths,
      *     errors, and manifests.
      * @private
      */
     add_: function(failures) {
       // If a failure is already being displayed, unhide the last item.
       if (this.failures_.length > 0)
         this.failures_[this.failures_.length - 1].listElement.hidden = false;
       failures.forEach(function(failure) {
-        var listItem = document.createElement('li');
+        var listItem = /** @type {HTMLLIElement} */(
+            document.createElement('li'));
         listItem.textContent = failure.path;
         this.additional_.list.appendChild(listItem);
         this.failures_.push(new Failure(failure.path,
                                         failure.error,
                                         failure.manifest,
                                         listItem));
       }.bind(this));
       // Hide the last item because the UI is displaying its information.
       this.failures_[this.failures_.length - 1].listElement.hidden = true;
       this.show_();
@@ skipping 44 matching lines @@
    * The ExtensionLoader is the class in charge of loading unpacked extensions.
    * @constructor
    */
   function ExtensionLoader() {
     /**
      * The ExtensionLoadError to show any errors from loading an unpacked
      * extension.
      * @type {ExtensionLoadError}
      * @private
      */
-    this.loadError_ = new ExtensionLoadError($('extension-load-error'));
+    this.loadError_ = new ExtensionLoadError(
+        /** @type {HTMLDivElement} */($('extension-load-error')));
   }
 
   cr.addSingletonGetter(ExtensionLoader);
 
   ExtensionLoader.prototype = {
     /**
      * Begin the sequence of loading an unpacked extension. If an error is
      * encountered, this object will get notified via notifyFailed().
      */
     loadUnpacked: function() {
       chrome.send('extensionLoaderLoadUnpacked');
     },
 
     /**
      * Notify the ExtensionLoader that loading an unpacked extension failed.
      * Add the failure to failures_ and show the ExtensionLoadError.
      * @param {Array.<Object>} failures Array of failures containing paths,
      *     errors, and manifests.
      */
     notifyFailed: function(failures) {
       this.loadError_.add_(failures);
     },
   };
 
-  /*
+  /**
    * A static forwarding function for ExtensionLoader.notifyFailed.
    * @param {Array.<Object>} failures Array of failures containing paths,
    *     errors, and manifests.
    * @see ExtensionLoader.notifyFailed
    */
   ExtensionLoader.notifyLoadFailed = function(failures) {
     ExtensionLoader.getInstance().notifyFailed(failures);
   };
 
   return {
     ExtensionLoader: ExtensionLoader
   };
 });