Typecheck JS files for chrome://help before doing import transition

ui/webui/resources/js/cr/ui/focus_manager.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('cr.ui', function() {
   /**
    * Constructor for FocusManager singleton. Checks focus of elements to ensure
    * that elements in "background" pages (i.e., those in a dialog that is not
    * the topmost overlay) do not receive focus.
    * @constructor
    */
   function FocusManager() {
   }
 
   FocusManager.prototype = {
     /**
      * Whether focus is being transferred backward or forward through the DOM.
      * @type {boolean}
      * @private
      */
     focusDirBackwards_: false,
 
     /**
      * Determines whether the |child| is a descendant of |parent| in the page's
      * DOM.
-     * @param {Element} parent The parent element to test.
-     * @param {Element} child The child element to test.
+     * @param {Node} parent The parent element to test.
+     * @param {Node} child The child element to test.
      * @return {boolean} True if |child| is a descendant of |parent|.
      * @private
      */
     isDescendantOf_: function(parent, child) {
-      return parent && !(parent === child) && parent.contains(child);
+      return !!parent && !(parent === child) && parent.contains(child);
     },
 
     /**
      * Returns the parent element containing all elements which should be
      * allowed to receive focus.
      * @return {Element} The element containing focusable elements.
      */
     getFocusParent: function() {
       return document.body;
     },
 
     /**
      * Returns the elements on the page capable of receiving focus.
-     * @return {Array.Element} The focusable elements.
+     * @return {Array.<Element>} The focusable elements.
      */
     getFocusableElements_: function() {
       var focusableDiv = this.getFocusParent();
 
       // Create a TreeWalker object to traverse the DOM from |focusableDiv|.
       var treeWalker = document.createTreeWalker(
           focusableDiv,
           NodeFilter.SHOW_ELEMENT,
-          { acceptNode: function(node) {
+          /** @type {NodeFilter} */
+          ({
+            acceptNode: function(node) {
               var style = window.getComputedStyle(node);
               // Reject all hidden nodes. FILTER_REJECT also rejects these
               // nodes' children, so non-hidden elements that are descendants of
               // hidden <div>s will correctly be rejected.
               if (node.hidden || style.display == 'none' ||
                   style.visibility == 'hidden') {
                 return NodeFilter.FILTER_REJECT;
               }
 
               // Skip nodes that cannot receive focus. FILTER_SKIP does not
               // cause this node's children also to be skipped.
               if (node.disabled || node.tabIndex < 0)
                 return NodeFilter.FILTER_SKIP;
 
               // Accept nodes that are non-hidden and focusable.
               return NodeFilter.FILTER_ACCEPT;
             }
-          },
+          }),
           false);
 
       var focusable = [];
       while (treeWalker.nextNode())
         focusable.push(treeWalker.currentNode);
 
       return focusable;
     },
 
     /**
      * Dispatches an 'elementFocused' event to notify an element that it has
      * received focus. When focus wraps around within the a page, only the
      * element that has focus after the wrapping receives an 'elementFocused'
      * event. This differs from the native 'focus' event which is received by
      * an element outside the page first, followed by a 'focus' on an element
      * within the page after the FocusManager has intervened.
-     * @param {Element} element The element that has received focus.
+     * @param {EventTarget} element The element that has received focus.
      * @private
      */
     dispatchFocusEvent_: function(element) {
       cr.dispatchSimpleEvent(element, 'elementFocused', true, false);
     },
 
     /**
      * Attempts to focus the appropriate element in the current dialog.
      * @private
      */
@@ skipping 47 matching lines @@
     },
 
     /**
      * Handler for focus events on the page.
      * @param {Event} event The focus event.
      * @private
      */
     onDocumentFocus_: function(event) {
       // If the element being focused is a descendant of the currently visible
       // page, focus is valid.
-      if (this.isDescendantOf_(this.getFocusParent(), event.target)) {
+      var targetNode = /** @type {Node} */(event.target);
+      if (this.isDescendantOf_(this.getFocusParent(), targetNode)) {
         this.dispatchFocusEvent_(event.target);
         return;
       }
 
       // Focus event handlers for descendant elements might dispatch another
       // focus event.
       event.stopPropagation();
 
       // The target of the focus event is not in the topmost visible page and
       // should not be focused.
@@ skipping 58 matching lines @@
         window.focus();
         event.preventDefault();
       }
     }, false);
   };
 
   return {
     FocusManager: FocusManager,
   };
 });