Run clang-format on ui/webui/resources

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() {
-  }
+  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 {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);
     },
 
     /**
      * 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;
-    },
+    getFocusParent: function() { return document.body; },
 
     /**
      * Returns the elements on the page capable of receiving focus.
      * @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,
+          focusableDiv, NodeFilter.SHOW_ELEMENT,
           /** @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;
@@ skipping 78 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.
-      var targetNode = /** @type {Node} */(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
@@ skipping 16 matching lines @@
         // If the "Shift" key is held, focus is being transferred backward in
         // the page.
         this.focusDirBackwards_ = event.shiftKey ? true : false;
       }
     },
 
     /**
      * Initializes the FocusManager by listening for events in the document.
      */
     initialize: function() {
-      document.addEventListener('focus', this.onDocumentFocus_.bind(this),
-          true);
-      document.addEventListener('keydown', this.onDocumentKeyDown_.bind(this),
-          true);
+      document.addEventListener(
+          'focus', this.onDocumentFocus_.bind(this), true);
+      document.addEventListener(
+          'keydown', this.onDocumentKeyDown_.bind(this), true);
     },
   };
 
   return {
     FocusManager: FocusManager,
   };
 });