Run clang-format on ui/webui/resources

ui/webui/resources/js/util.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.
 
 // <include src="assert.js">
 
 /**
  * Alias for document.getElementById. Found elements must be HTMLElements.
  * @param {string} id The ID of the element to find.
  * @return {HTMLElement} The found element or null if not found.
@@ skipping 22 matching lines @@
  * @param {string} msg The text to be pronounced.
  */
 function announceAccessibleMessage(msg) {
   var element = document.createElement('div');
   element.setAttribute('aria-live', 'polite');
   element.style.position = 'fixed';
   element.style.left = '-9999px';
   element.style.height = '0px';
   element.innerText = msg;
   document.body.appendChild(element);
-  window.setTimeout(function() {
-    document.body.removeChild(element);
-  }, 0);
+  window.setTimeout(function() { document.body.removeChild(element); }, 0);
 }
 
 /**
  * Generates a CSS url string.
  * @param {string} s The URL to generate the CSS url for.
  * @return {string} The CSS url string.
  */
 function url(s) {
   // http://www.w3.org/TR/css3-values/#uris
   // Parentheses, commas, whitespace characters, single quotes (') and double
@@ skipping 43 matching lines @@
 
   return location.origin + location.pathname + newQuery + location.hash;
 }
 
 /**
  * @param {Node} el A node to search for ancestors with |className|.
  * @param {string} className A class to search for.
  * @return {Element} A node with class of |className| or null if none is found.
  */
 function findAncestorByClass(el, className) {
-  return /** @type {Element} */(findAncestor(el, function(el) {
+  return /** @type {Element} */ (findAncestor(el, function(el) {
     return el.classList && el.classList.contains(className);
   }));
 }
 
 /**
  * Return the first ancestor for which the {@code predicate} returns true.
  * @param {Node} node The node to check.
  * @param {function(Node):boolean} predicate The function that tests the
  *     nodes.
  * @return {Node} The found ancestor or null if not found.
@@ skipping 39 matching lines @@
   };
 }
 
 /**
  * TODO(dbeam): DO NOT USE. THIS IS DEPRECATED. Use an action-link instead.
  * Call this to stop clicks on <a href="#"> links from scrolling to the top of
  * the page (and possibly showing a # in the link).
  */
 function preventDefaultOnPoundLinkClicks() {
   document.addEventListener('click', function(e) {
-    var anchor = findAncestor(/** @type {Node} */(e.target), function(el) {
+    var anchor = findAncestor(/** @type {Node} */ (e.target), function(el) {
       return el.tagName == 'A';
     });
     // Use getAttribute() to prevent URL normalization.
     if (anchor && anchor.getAttribute('href') == '#')
       e.preventDefault();
   });
 }
 
 /**
  * Check the directionality of the page.
  * @return {boolean} True if Chrome is running an RTL UI.
  */
 function isRTL() {
   return document.documentElement.dir == 'rtl';
 }
 
 /**
  * Get an element that's known to exist by its ID. We use this instead of just
  * calling getElementById and not checking the result because this lets us
  * satisfy the JSCompiler type system.
  * @param {string} id The identifier name.
  * @return {!HTMLElement} the Element.
  */
 function getRequiredElement(id) {
-  return assertInstanceof($(id), HTMLElement,
-                          'Missing required element: ' + id);
+  return assertInstanceof(
+      $(id), HTMLElement, 'Missing required element: ' + id);
 }
 
 /**
  * Query an element that's known to exist by a selector. We use this instead of
  * just calling querySelector and not checking the result because this lets us
  * satisfy the JSCompiler type system.
  * @param {string} selectors CSS selectors to query the element.
  * @param {(!Document|!DocumentFragment|!Element)=} opt_context An optional
  *     context object for querySelector.
  * @return {!HTMLElement} the Element.
  */
 function queryRequiredElement(selectors, opt_context) {
   var element = (opt_context || document).querySelector(selectors);
-  return assertInstanceof(element, HTMLElement,
-                          'Missing required element: ' + selectors);
+  return assertInstanceof(
+      element, HTMLElement, 'Missing required element: ' + selectors);
 }
 
 // Handle click on a link. If the link points to a chrome: or file: url, then
 // call into the browser to do the navigation.
 ['click', 'auxclick'].forEach(function(eventName) {
   document.addEventListener(eventName, function(e) {
     if (e.button > 1)
-      return; // Ignore buttons other than left and middle.
+      return;  // Ignore buttons other than left and middle.
     if (e.defaultPrevented)
       return;
 
     var eventPath = e.path;
     var anchor = null;
     if (eventPath) {
       for (var i = 0; i < eventPath.length; i++) {
         var element = eventPath[i];
         if (element.tagName === 'A' && element.href) {
           anchor = element;
           break;
         }
       }
     }
 
     // Fallback if Event.path is not available.
     var el = e.target;
     if (!anchor && el.nodeType == Node.ELEMENT_NODE &&
         el.webkitMatchesSelector('A, A *')) {
       while (el.tagName != 'A') {
         el = el.parentElement;
       }
       anchor = el;
     }
 
     if (!anchor)
       return;
 
-    anchor = /** @type {!HTMLAnchorElement} */(anchor);
+    anchor = /** @type {!HTMLAnchorElement} */ (anchor);
     if ((anchor.protocol == 'file:' || anchor.protocol == 'about:') &&
         (e.button == 0 || e.button == 1)) {
       chrome.send('navigateToUrl', [
-        anchor.href,
-        anchor.target,
-        e.button,
-        e.altKey,
-        e.ctrlKey,
-        e.metaKey,
+        anchor.href, anchor.target, e.button, e.altKey, e.ctrlKey, e.metaKey,
         e.shiftKey
       ]);
       e.preventDefault();
     }
   });
 });
 
 /**
  * Creates a new URL which is the old URL with a GET param of key=value.
  * @param {string} url The base URL. There is not sanity checking on the URL so
@@ skipping 91 matching lines @@
   doc.documentElement.scrollLeft = doc.body.scrollLeft = value;
 }
 
 /**
  * Replaces '&', '<', '>', '"', and ''' characters with their HTML encoding.
  * @param {string} original The original string.
  * @return {string} The string with all the characters mentioned above replaced.
  */
 function HTMLEscape(original) {
   return original.replace(/&/g, '&amp;')
-                 .replace(/</g, '&lt;')
-                 .replace(/>/g, '&gt;')
-                 .replace(/"/g, '&quot;')
-                 .replace(/'/g, '&#39;');
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;')
+      .replace(/'/g, '&#39;');
 }
 
 /**
  * Shortens the provided string (if necessary) to a string of length at most
  * |maxLength|.
  * @param {string} original The original string.
  * @param {number} maxLength The maximum length allowed for the string.
  * @return {string} The original string if its length does not exceed
  *     |maxLength|. Otherwise the first |maxLength| - 1 characters with '...'
  *     appended.
@@ skipping 39 matching lines @@
 }
 
 // <if expr="is_ios">
 // Polyfill 'key' in KeyboardEvent for iOS.
 // This function is not intended to be complete but should
 // be sufficient enough to have iOS work correctly while
 // it does not support key yet.
 if (!('key' in KeyboardEvent.prototype)) {
   Object.defineProperty(KeyboardEvent.prototype, 'key', {
     /** @this {KeyboardEvent} */
-    get: function () {
+    get: function() {
       // 0-9
       if (this.keyCode >= 0x30 && this.keyCode <= 0x39)
         return String.fromCharCode(this.keyCode);
 
       // A-Z
       if (this.keyCode >= 0x41 && this.keyCode <= 0x5a) {
         var result = String.fromCharCode(this.keyCode).toLowerCase();
         if (this.shiftKey)
           result = result.toUpperCase();
         return result;
       }
 
       // Special characters
-      switch(this.keyCode) {
-        case 0x08: return 'Backspace';
-        case 0x09: return 'Tab';
-        case 0x0d: return 'Enter';
-        case 0x10: return 'Shift';
-        case 0x11: return 'Control';
-        case 0x12: return 'Alt';
-        case 0x1b: return 'Escape';
-        case 0x20: return ' ';
-        case 0x21: return 'PageUp';
-        case 0x22: return 'PageDown';
-        case 0x23: return 'End';
-        case 0x24: return 'Home';
-        case 0x25: return 'ArrowLeft';
-        case 0x26: return 'ArrowUp';
-        case 0x27: return 'ArrowRight';
-        case 0x28: return 'ArrowDown';
-        case 0x2d: return 'Insert';
-        case 0x2e: return 'Delete';
-        case 0x5b: return 'Meta';
-        case 0x70: return 'F1';
-        case 0x71: return 'F2';
-        case 0x72: return 'F3';
-        case 0x73: return 'F4';
-        case 0x74: return 'F5';
-        case 0x75: return 'F6';
-        case 0x76: return 'F7';
-        case 0x77: return 'F8';
-        case 0x78: return 'F9';
-        case 0x79: return 'F10';
-        case 0x7a: return 'F11';
-        case 0x7b: return 'F12';
-        case 0xbb: return '=';
-        case 0xbd: return '-';
-        case 0xdb: return '[';
-        case 0xdd: return ']';
+      switch (this.keyCode) {
+        case 0x08:
+          return 'Backspace';
+        case 0x09:
+          return 'Tab';
+        case 0x0d:
+          return 'Enter';
+        case 0x10:
+          return 'Shift';
+        case 0x11:
+          return 'Control';
+        case 0x12:
+          return 'Alt';
+        case 0x1b:
+          return 'Escape';
+        case 0x20:
+          return ' ';
+        case 0x21:
+          return 'PageUp';
+        case 0x22:
+          return 'PageDown';
+        case 0x23:
+          return 'End';
+        case 0x24:
+          return 'Home';
+        case 0x25:
+          return 'ArrowLeft';
+        case 0x26:
+          return 'ArrowUp';
+        case 0x27:
+          return 'ArrowRight';
+        case 0x28:
+          return 'ArrowDown';
+        case 0x2d:
+          return 'Insert';
+        case 0x2e:
+          return 'Delete';
+        case 0x5b:
+          return 'Meta';
+        case 0x70:
+          return 'F1';
+        case 0x71:
+          return 'F2';
+        case 0x72:
+          return 'F3';
+        case 0x73:
+          return 'F4';
+        case 0x74:
+          return 'F5';
+        case 0x75:
+          return 'F6';
+        case 0x76:
+          return 'F7';
+        case 0x77:
+          return 'F8';
+        case 0x78:
+          return 'F9';
+        case 0x79:
+          return 'F10';
+        case 0x7a:
+          return 'F11';
+        case 0x7b:
+          return 'F12';
+        case 0xbb:
+          return '=';
+        case 0xbd:
+          return '-';
+        case 0xdb:
+          return '[';
+        case 0xdd:
+          return ']';
       }
       return 'Unidentified';
     }
   });
 } else {
-  window.console.log("KeyboardEvent.Key polyfill not required");
+  window.console.log('KeyboardEvent.Key polyfill not required');
 }
 // </if>  /* is_ios */
 
 /**
  * Helper to convert callback-based define() API to a promise-based API.
  * @suppress {undefinedVars}
  * @param {!Array<string>} moduleNames
  * @return {!Promise}
  */
 function importModules(moduleNames) {
   return new Promise(function(resolve) {
-    define(moduleNames, function() {
-      resolve(Array.from(arguments));
-    });
+    define(moduleNames, function() { resolve(Array.from(arguments)); });
   });
 }
 
 /**
  * @param {!Event} e
  * @return {boolean} Whether a modifier key was down when processing |e|.
  */
 function hasKeyModifiers(e) {
   return !!(e.altKey || e.ctrlKey || e.metaKey || e.shiftKey);
 }