Run clang-format on .js files in c/b/r/chromeos/chromevox

chrome/browser/resources/chromeos/chromevox/common/dom_util.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.
 
 /**
  * @fileoverview A collection of JavaScript utilities used to simplify working
  * with the DOM.
  */
 
 
 goog.provide('cvox.DomUtil');
 
 goog.require('cvox.AbstractTts');
 goog.require('cvox.AriaUtil');
 goog.require('cvox.ChromeVox');
 goog.require('cvox.DomPredicates');
 goog.require('cvox.Memoize');
 goog.require('cvox.NodeState');
 goog.require('cvox.XpathUtil');
 
 
 
 /**
  * Create the namespace
  * @constructor
  */
-cvox.DomUtil = function() {
-};
+cvox.DomUtil = function() {};
 
 
 /**
  * Note: If you are adding a new mapping, the new message identifier needs a
  * corresponding braille message. For example, a message id 'tag_button'
  * requires another message 'tag_button_brl' within messages.js.
  * @type {Object}
  */
 cvox.DomUtil.INPUT_TYPE_TO_INFORMATION_TABLE_MSG = {
-  'button' : 'role_button',
-  'checkbox' : 'role_checkbox',
-  'color' : 'input_type_color',
-  'datetime' : 'input_type_datetime',
-  'datetime-local' : 'input_type_datetime_local',
-  'date' : 'input_type_date',
-  'email' : 'input_type_email',
-  'file' : 'input_type_file',
-  'image' : 'role_button',
-  'month' : 'input_type_month',
-  'number' : 'input_type_number',
-  'password' : 'input_type_password',
-  'radio' : 'role_radio',
-  'range' : 'role_slider',
-  'reset' : 'input_type_reset',
-  'search' : 'input_type_search',
-  'submit' : 'role_button',
-  'tel' : 'input_type_number',
-  'text' : 'input_type_text',
-  'url' : 'input_type_url',
-  'week' : 'input_type_week'
+  'button': 'role_button',
+  'checkbox': 'role_checkbox',
+  'color': 'input_type_color',
+  'datetime': 'input_type_datetime',
+  'datetime-local': 'input_type_datetime_local',
+  'date': 'input_type_date',
+  'email': 'input_type_email',
+  'file': 'input_type_file',
+  'image': 'role_button',
+  'month': 'input_type_month',
+  'number': 'input_type_number',
+  'password': 'input_type_password',
+  'radio': 'role_radio',
+  'range': 'role_slider',
+  'reset': 'input_type_reset',
+  'search': 'input_type_search',
+  'submit': 'role_button',
+  'tel': 'input_type_number',
+  'text': 'input_type_text',
+  'url': 'input_type_url',
+  'week': 'input_type_week'
 };
 
 
 /**
  * Note: If you are adding a new mapping, the new message identifier needs a
  * corresponding braille message. For example, a message id 'tag_button'
  * requires another message 'tag_button_brl' within messages.js.
  * @type {Object}
  */
 cvox.DomUtil.TAG_TO_INFORMATION_TABLE_VERBOSE_MSG = {
-  'A' : 'role_link',
-  'ARTICLE' : 'tag_article',
-  'ASIDE' : 'tag_aside',
-  'AUDIO' : 'tag_audio',
-  'BUTTON' : 'role_button',
-  'FOOTER' : 'tag_footer',
-  'H1' : 'tag_h1',
-  'H2' : 'tag_h2',
-  'H3' : 'tag_h3',
-  'H4' : 'tag_h4',
-  'H5' : 'tag_h5',
-  'H6' : 'tag_h6',
-  'HEADER' : 'tag_header',
-  'HGROUP' : 'tag_hgroup',
-  'LI' : 'tag_li',
-  'MARK' : 'tag_mark',
-  'NAV' : 'tag_nav',
-  'OL' : 'tag_ol',
-  'SECTION' : 'tag_section',
-  'SELECT' : 'tag_select',
-  'TABLE' : 'tag_table',
-  'TEXTAREA' : 'tag_textarea',
-  'TIME' : 'tag_time',
-  'UL' : 'tag_ul',
-  'VIDEO' : 'tag_video'
+  'A': 'role_link',
+  'ARTICLE': 'tag_article',
+  'ASIDE': 'tag_aside',
+  'AUDIO': 'tag_audio',
+  'BUTTON': 'role_button',
+  'FOOTER': 'tag_footer',
+  'H1': 'tag_h1',
+  'H2': 'tag_h2',
+  'H3': 'tag_h3',
+  'H4': 'tag_h4',
+  'H5': 'tag_h5',
+  'H6': 'tag_h6',
+  'HEADER': 'tag_header',
+  'HGROUP': 'tag_hgroup',
+  'LI': 'tag_li',
+  'MARK': 'tag_mark',
+  'NAV': 'tag_nav',
+  'OL': 'tag_ol',
+  'SECTION': 'tag_section',
+  'SELECT': 'tag_select',
+  'TABLE': 'tag_table',
+  'TEXTAREA': 'tag_textarea',
+  'TIME': 'tag_time',
+  'UL': 'tag_ul',
+  'VIDEO': 'tag_video'
 };
 
 /**
  * ChromeVox does not speak the omitted tags.
  * @type {Object}
  */
 cvox.DomUtil.TAG_TO_INFORMATION_TABLE_BRIEF_MSG = {
-  'AUDIO' : 'tag_audio',
-  'BUTTON' : 'role_button',
-  'SELECT' : 'tag_select',
-  'TABLE' : 'tag_table',
-  'TEXTAREA' : 'tag_textarea',
-  'VIDEO' : 'tag_video'
+  'AUDIO': 'tag_audio',
+  'BUTTON': 'role_button',
+  'SELECT': 'tag_select',
+  'TABLE': 'tag_table',
+  'TEXTAREA': 'tag_textarea',
+  'VIDEO': 'tag_video'
 };
 
 /**
  * These tags are treated as text formatters.
  * @type {Array<string>}
  */
-cvox.DomUtil.FORMATTING_TAGS =
-    ['B', 'BIG', 'CITE', 'CODE', 'DFN', 'EM', 'I', 'KBD', 'SAMP', 'SMALL',
-     'SPAN', 'STRIKE', 'STRONG', 'SUB', 'SUP', 'U', 'VAR'];
+cvox.DomUtil.FORMATTING_TAGS = [
+  'B', 'BIG', 'CITE', 'CODE', 'DFN', 'EM', 'I', 'KBD', 'SAMP', 'SMALL', 'SPAN',
+  'STRIKE', 'STRONG', 'SUB', 'SUP', 'U', 'VAR'
+];
 
 /**
  * Determine if the given node is visible on the page. This does not check if
  * it is inside the document view-port as some sites try to communicate with
  * screen readers with such elements.
  * @param {Node} node The node to determine as visible or not.
  * @param {{checkAncestors: (boolean|undefined),
             checkDescendants: (boolean|undefined)}=} opt_options
  *     In certain cases, we already have information
  *     on the context of the node. To improve performance and avoid redundant
@@ skipping 17 matching lines @@
     }
   }
 
   // Generate a unique function name based on the arguments, and
   // memoize the result of the internal visibility computation so that
   // within the same call stack, we don't need to recompute the visibility
   // of the same node.
   var fname = 'isVisible-' + checkAncestors + '-' + checkDescendants;
   return /** @type {boolean} */ (cvox.Memoize.memoize(
       cvox.DomUtil.computeIsVisible_.bind(
-          this, node, checkAncestors, checkDescendants), fname, node));
+          this, node, checkAncestors, checkDescendants),
+      fname, node));
 };
 
 /**
  * Implementation of |cvox.DomUtil.isVisible|.
  * @param {Node} node The node to determine as visible or not.
  * @param {boolean} checkAncestors True if we should check the ancestor chain
  *       for forced invisibility traits of descendants.
  * @param {boolean} checkDescendants True if we should consider descendants of
  *       the  given node for visible elements.
  * @return {boolean} True if the node is visible.
  * @private
  */
 cvox.DomUtil.computeIsVisible_ = function(
     node, checkAncestors, checkDescendants) {
   // If the node is an iframe that we can never inject into, consider it hidden.
   if (node.tagName == 'IFRAME' && !node.src) {
     return false;
   }
 
   // If the node is being forced visible by ARIA, ARIA wins.
   if (cvox.AriaUtil.isForcedVisibleRecursive(node)) {
     return true;
   }
 
   // Confirm that no subtree containing node is invisible.
-  if (checkAncestors &&
-      cvox.DomUtil.hasInvisibleAncestor_(node)) {
+  if (checkAncestors && cvox.DomUtil.hasInvisibleAncestor_(node)) {
     return false;
   }
 
   // If the node's subtree has a visible node, we declare it as visible.
   if (cvox.DomUtil.hasVisibleNodeSubtree_(node, checkDescendants)) {
     return true;
   }
 
   return false;
 };
@@ skipping 35 matching lines @@
  *     Sometimes we already have information about the descendants, and we do
  *     not need to check them again.
  * @return {boolean} True if the subtree contains a visible node.
  * @private
  */
 cvox.DomUtil.hasVisibleNodeSubtree_ = function(root, recursive) {
   if (!(root instanceof Element)) {
     if (!root.parentElement) {
       return false;
     }
-    var parentStyle = document.defaultView
-        .getComputedStyle(root.parentElement, null);
+    var parentStyle =
+        document.defaultView.getComputedStyle(root.parentElement, null);
     var isVisibleParent = !cvox.DomUtil.isInvisibleStyle(parentStyle);
     return isVisibleParent;
   }
 
   var rootStyle = document.defaultView.getComputedStyle(root, null);
   var isRootVisible = !cvox.DomUtil.isInvisibleStyle(rootStyle);
   if (isRootVisible) {
     return true;
   }
   var isSubtreeInvisible = cvox.DomUtil.isInvisibleStyle(rootStyle, true);
@@ skipping 95 matching lines @@
  * @param {boolean=} opt_allowHidden Allows hidden nodes during descent.
  * @return {boolean} True if the node is a leaf node.
  */
 cvox.DomUtil.isLeafNode = function(node, opt_allowHidden) {
   // If it's not an Element, then it's a leaf if it has no first child.
   if (!(node instanceof Element)) {
     return (node.firstChild == null);
   }
 
   // Now we know for sure it's an element.
-  var element = /** @type {Element} */(node);
+  var element = /** @type {Element} */ (node);
   if (!opt_allowHidden &&
       !cvox.DomUtil.isVisible(element, {checkAncestors: false})) {
     return true;
   }
   if (!opt_allowHidden && cvox.AriaUtil.isHidden(element)) {
     return true;
   }
   if (cvox.AriaUtil.isLeafElement(element)) {
     return true;
   }
@@ skipping 37 matching lines @@
  * @param {Node} node The node to be checked.
  * @param {?string} tagName The tag to check for, or null if the tag
  * doesn't matter.
  * @param {?string=} className The class to check for, or null if the class
  * doesn't matter.
  * @return {boolean} True if the node or one of its ancestor has the specified
  * tag.
  */
 cvox.DomUtil.isDescendantOf = function(node, tagName, className) {
   while (node) {
-
-    if (tagName && className &&
-        (node.tagName && (node.tagName == tagName)) &&
+    if (tagName && className && (node.tagName && (node.tagName == tagName)) &&
         (node.className && (node.className == className))) {
       return true;
-    } else if (tagName && !className &&
-               (node.tagName && (node.tagName == tagName))) {
+    } else if (
+        tagName && !className && (node.tagName && (node.tagName == tagName))) {
       return true;
-    } else if (!tagName && className &&
-               (node.className && (node.className == className))) {
+    } else if (
+        !tagName && className &&
+        (node.className && (node.className == className))) {
       return true;
     }
     node = node.parentNode;
   }
   return false;
 };
 
 
 /**
  * Determines whether or not a node is or is the descendant of another node.
@@ skipping 35 matching lines @@
  * @private
  */
 cvox.DomUtil.getBaseLabel_ = function(node, recursive, includeControls) {
   var label = '';
   if (node.hasAttribute) {
     if (node.hasAttribute('aria-labelledby')) {
       var labelNodeIds = node.getAttribute('aria-labelledby').split(' ');
       for (var labelNodeId, i = 0; labelNodeId = labelNodeIds[i]; i++) {
         var labelNode = document.getElementById(labelNodeId);
         if (labelNode) {
-          label += ' ' + cvox.DomUtil.getName(
-              labelNode, true, includeControls, true);
+          label += ' ' +
+              cvox.DomUtil.getName(labelNode, true, includeControls, true);
         }
       }
     } else if (node.hasAttribute('aria-label')) {
       label = node.getAttribute('aria-label');
     } else if (node.constructor == HTMLImageElement) {
       label = cvox.DomUtil.getImageTitle(node);
     } else if (node.tagName == 'FIELDSET') {
       // Other labels will trump fieldset legend with this implementation.
       // Depending on how this works out on the web, we may later switch this
       // to appending the fieldset legend to any existing label.
@@ skipping 92 matching lines @@
  * Determines if a node has a name obtained from concatinating the names of its
  * children.
  * @param {!Node} node The node under consideration.
  * @param {boolean=} opt_allowHidden Allows hidden nodes in name computation.
  * @return {boolean} True if node has name based on children.
  * @private
  */
 cvox.DomUtil.hasChildrenBasedName_ = function(node, opt_allowHidden) {
   if (!!cvox.DomPredicates.linkPredicate([node]) ||
       !!cvox.DomPredicates.headingPredicate([node]) ||
-      node.tagName == 'BUTTON' ||
-      cvox.AriaUtil.isControlWidget(node) ||
+      node.tagName == 'BUTTON' || cvox.AriaUtil.isControlWidget(node) ||
       !cvox.DomUtil.isLeafNode(node, opt_allowHidden)) {
     return true;
   } else {
     return false;
   }
 };
 
 /**
  * Get the name of a node: this includes all static text content and any
  * HTML-author-specified label, title, alt text, aria-label, etc. - but
@@ skipping 56 matching lines @@
       return placeholder;
     }
   }
 
   if (label.length > 0) {
     return label;
   }
 
   // Fall back to naming via title only if there is no text content.
   if (cvox.DomUtil.collapseWhitespace(node.textContent).length == 0 &&
-      node.hasAttribute &&
-      node.hasAttribute('title')) {
+      node.hasAttribute && node.hasAttribute('title')) {
     return node.getAttribute('title');
   }
 
   if (!recursive) {
     return '';
   }
 
   if (cvox.AriaUtil.isCompositeControl(node)) {
     return '';
   }
@@ skipping 22 matching lines @@
   var name = '';
   var delimiter = '';
   for (var i = 0; i < node.childNodes.length; i++) {
     var child = node.childNodes[i];
     var prevChild = node.childNodes[i - 1] || child;
     if (!includeControls && cvox.DomUtil.isControl(child)) {
       continue;
     }
     var isVisible = cvox.DomUtil.isVisible(child, {checkAncestors: false});
     if (opt_allowHidden || (isVisible && !cvox.AriaUtil.isHidden(child))) {
-      delimiter = (prevChild.tagName == 'SPAN' ||
-                   child.tagName == 'SPAN' ||
+      delimiter = (prevChild.tagName == 'SPAN' || child.tagName == 'SPAN' ||
                    child.parentNode.tagName == 'SPAN') ?
-          '' : ' ';
+          '' :
+          ' ';
       name += delimiter + cvox.DomUtil.getName(child, true, includeControls);
     }
   }
 
   return name;
 };
 
 /**
  * Get any prefix text for the given node.
  * This includes list style text for the leftmost leaf node under a listitem.
  * @param {Node} node Compute prefix for this node.
  * @param {number=} opt_index Starting offset into the given node's text.
  * @return {string} Prefix text, if any.
  */
 cvox.DomUtil.getPrefixText = function(node, opt_index) {
   opt_index = opt_index || 0;
 
   // Generate list style text.
   var ancestors = cvox.DomUtil.getAncestors(node);
   var prefix = '';
   var firstListitem = cvox.DomPredicates.listItemPredicate(ancestors);
 
   var leftmost = firstListitem;
   while (leftmost && leftmost.firstChild) {
     leftmost = leftmost.firstChild;
   }
 
   // Do nothing if we're not at the leftmost leaf.
-  if (firstListitem &&
-      firstListitem.parentNode &&
-      opt_index == 0 &&
-      firstListitem.parentNode.tagName == 'OL' &&
-          node == leftmost &&
+  if (firstListitem && firstListitem.parentNode && opt_index == 0 &&
+      firstListitem.parentNode.tagName == 'OL' && node == leftmost &&
       document.defaultView.getComputedStyle(firstListitem.parentElement)
-          .listStyleType != 'none') {
-    var items = cvox.DomUtil.toArray(firstListitem.parentNode.children).filter(
-        function(li) { return li.tagName == 'LI'; });
+              .listStyleType != 'none') {
+    var items = cvox.DomUtil.toArray(firstListitem.parentNode.children)
+                    .filter(function(li) {
+                      return li.tagName == 'LI';
+                    });
     var position = items.indexOf(firstListitem) + 1;
     // TODO(dtseng): Support all list style types.
-    if (document.defaultView.getComputedStyle(
-            firstListitem.parentElement).listStyleType.indexOf('latin') != -1) {
+    if (document.defaultView.getComputedStyle(firstListitem.parentElement)
+            .listStyleType.indexOf('latin') != -1) {
       position--;
       prefix = String.fromCharCode('A'.charCodeAt(0) + position % 26);
     } else {
       prefix = position;
     }
     prefix += '. ';
   }
   return prefix;
 };
 
 
 /**
  * Use heuristics to guess at the label of a control, to be used if one
  * is not explicitly set in the DOM. This is useful when a control
  * field gets focus, but probably not useful when browsing the page
  * element at a time.
  * @param {Node} node The node to get the label from.
  * @return {string} The name of the control, using heuristics.
  */
 cvox.DomUtil.getControlLabelHeuristics = function(node) {
   // If the node explicitly has aria-label or title set to '',
   // treat it the same way as alt='' and do not guess - just assume
   // the web developer knew what they were doing and wanted
   // no title/label for that control.
   if (node.hasAttribute &&
       ((node.hasAttribute('aria-label') &&
-      (node.getAttribute('aria-label') == '')) ||
-      (node.hasAttribute('aria-title') &&
-      (node.getAttribute('aria-title') == '')))) {
+        (node.getAttribute('aria-label') == '')) ||
+       (node.hasAttribute('aria-title') &&
+        (node.getAttribute('aria-title') == '')))) {
     return '';
   }
 
   // TODO (clchen, rshearer): Implement heuristics for getting the label
   // information from the table headers once the code for getting table
   // headers quickly is implemented.
 
   // If no description has been found yet and heuristics are enabled,
   // then try getting the content from the closest node.
   var prevNode = cvox.DomUtil.previousLeafNode(node);
   var prevTraversalCount = 0;
-  while (prevNode && (!cvox.DomUtil.hasContent(prevNode) ||
-      cvox.DomUtil.isControl(prevNode))) {
+  while (prevNode &&
+         (!cvox.DomUtil.hasContent(prevNode) ||
+          cvox.DomUtil.isControl(prevNode))) {
     prevNode = cvox.DomUtil.previousLeafNode(prevNode);
     prevTraversalCount++;
   }
   var nextNode = cvox.DomUtil.directedNextLeafNode(node);
   var nextTraversalCount = 0;
-  while (nextNode && (!cvox.DomUtil.hasContent(nextNode) ||
-      cvox.DomUtil.isControl(nextNode))) {
+  while (nextNode &&
+         (!cvox.DomUtil.hasContent(nextNode) ||
+          cvox.DomUtil.isControl(nextNode))) {
     nextNode = cvox.DomUtil.directedNextLeafNode(nextNode);
     nextTraversalCount++;
   }
   var guessedLabelNode;
   if (prevNode && nextNode) {
     var parentNode = node;
     // Count the number of parent nodes until there is a shared parent; the
     // label is most likely in the same branch of the DOM as the control.
     // TODO (chaitanyag): Try to generalize this algorithm and move it to
     // its own function in DOM Utils.
@@ skipping 40 matching lines @@
  */
 cvox.DomUtil.getValue = function(node) {
   var activeDescendant = cvox.AriaUtil.getActiveDescendant(node);
   if (activeDescendant) {
     return cvox.DomUtil.collapseWhitespace(
         cvox.DomUtil.getValue(activeDescendant) + ' ' +
         cvox.DomUtil.getName(activeDescendant));
   }
 
   if (node.constructor == HTMLSelectElement) {
-    node = /** @type {HTMLSelectElement} */(node);
+    node = /** @type {HTMLSelectElement} */ (node);
     var value = '';
     var start = node.selectedOptions ? node.selectedOptions[0] : null;
     var end = node.selectedOptions ?
-        node.selectedOptions[node.selectedOptions.length - 1] : null;
+        node.selectedOptions[node.selectedOptions.length - 1] :
+        null;
     // TODO(dtseng): Keeping this stateless means we describe the start and end
     // of the selection only since we don't know which was added or
     // removed. Once we keep the previous selection, we can read the diff.
     if (start && end && start != end) {
-      value = Msgs.getMsg(
-        'selected_options_value', [start.text, end.text]);
+      value = Msgs.getMsg('selected_options_value', [start.text, end.text]);
     } else if (start) {
       value = start.text + '';
     }
     return value;
   }
 
   if (node.constructor == HTMLTextAreaElement) {
     return node.value;
   }
 
@@ skipping 33 matching lines @@
  */
 cvox.DomUtil.getImageTitle = function(node) {
   var text;
   if (node.hasAttribute('alt')) {
     text = node.alt;
   } else if (node.hasAttribute('title')) {
     text = node.title;
   } else {
     var url = node.src;
     if (url.substring(0, 4) != 'data') {
-      var filename = url.substring(
-          url.lastIndexOf('/') + 1, url.lastIndexOf('.'));
+      var filename =
+          url.substring(url.lastIndexOf('/') + 1, url.lastIndexOf('.'));
 
       // Hack to not speak the filename if it's ridiculously long.
       if (filename.length >= 1 && filename.length <= 16) {
         text = filename + ' Image';
       } else {
         text = 'Image';
       }
     } else {
       text = 'Image';
     }
@@ skipping 137 matching lines @@
   // when the control is reached.
   var enclosingLabel = node.parentElement;
   while (enclosingLabel && enclosingLabel.tagName != 'LABEL') {
     enclosingLabel = enclosingLabel.parentElement;
   }
   if (enclosingLabel) {
     var embeddedControl = enclosingLabel.querySelector(controlQuery);
     if (enclosingLabel.hasAttribute('for')) {
       var targetId = enclosingLabel.getAttribute('for');
       var targetNode = document.getElementById(targetId);
-      if (targetNode &&
-          cvox.DomUtil.isControl(targetNode) &&
+      if (targetNode && cvox.DomUtil.isControl(targetNode) &&
           !embeddedControl) {
         return false;
       }
     } else if (embeddedControl) {
       return false;
     }
   }
 
   // Skip any non-control content inside of a legend if the legend is correctly
   // nested within a fieldset. The legend text will get spoken when the fieldset
@@ skipping 38 matching lines @@
 
   if (cvox.DomUtil.isFocusable(node)) {
     return true;
   }
 
   // Skip anything referenced by another element on the page
   // via aria-labelledby.
   var labelledByTargets = cvox.DomUtil.getLabelledByTargets();
   var enclosingNodeWithId = node;
   while (enclosingNodeWithId) {
-    if (enclosingNodeWithId.id &&
-        labelledByTargets[enclosingNodeWithId.id]) {
+    if (enclosingNodeWithId.id && labelledByTargets[enclosingNodeWithId.id]) {
       // If we got here, some element on this page has an aria-labelledby
       // attribute listing this node as its id. As long as that "some" element
       // is not this element, we should return false, indicating this element
       // should be skipped.
       var attrValue = enclosingNodeWithId.getAttribute('aria-labelledby');
       if (attrValue) {
         var ids = attrValue.split(/ +/);
         if (ids.indexOf(enclosingNodeWithId.id) == -1) {
           return false;
         }
@@ skipping 72 matching lines @@
  * @param {Node} currentNode The current node.
  * @param {boolean=} opt_fallback True returns node's ancestors in the case
  * where node's ancestors is a subset of previousNode's ancestors.
  * @return {Array<Node>} An array of unique ancestors for the current node
  * (inclusive).
  */
 cvox.DomUtil.getUniqueAncestors = function(
     previousNode, currentNode, opt_fallback) {
   var prevAncestors = cvox.DomUtil.getAncestors(previousNode);
   var currentAncestors = cvox.DomUtil.getAncestors(currentNode);
-  var divergence = cvox.DomUtil.compareAncestors(prevAncestors,
-      currentAncestors);
+  var divergence =
+      cvox.DomUtil.compareAncestors(prevAncestors, currentAncestors);
   var diff = currentAncestors.slice(divergence);
   return (diff.length == 0 && opt_fallback) ? currentAncestors : diff;
 };
 
 
 /**
  * Returns a role message identifier for a node.
  * For a localized string, see cvox.DomUtil.getRole.
  * @param {Node} targetNode The node to get the role name for.
  * @param {number} verbosity The verbosity setting to use.
  * @return {string} The role message identifier for the targetNode.
  */
 cvox.DomUtil.getRoleMsg = function(targetNode, verbosity) {
   var info;
   info = cvox.AriaUtil.getRoleNameMsg(targetNode);
   if (!info) {
     if (targetNode.tagName == 'INPUT') {
       info = cvox.DomUtil.INPUT_TYPE_TO_INFORMATION_TABLE_MSG[targetNode.type];
-    } else if (targetNode.tagName == 'A' &&
-        cvox.DomUtil.isInternalLink(targetNode)) {
+    } else if (
+        targetNode.tagName == 'A' && cvox.DomUtil.isInternalLink(targetNode)) {
       info = 'internal_link';
-    } else if (targetNode.tagName == 'A' &&
-        targetNode.getAttribute('href') &&
+    } else if (
+        targetNode.tagName == 'A' && targetNode.getAttribute('href') &&
         cvox.ChromeVox.visitedUrls[targetNode.href]) {
       info = 'visited_link';
-    } else if (targetNode.tagName == 'A' &&
-        targetNode.getAttribute('name')) {
-      info = ''; // Don't want to add any role to anchors.
+    } else if (targetNode.tagName == 'A' && targetNode.getAttribute('name')) {
+      info = '';  // Don't want to add any role to anchors.
     } else if (targetNode.isContentEditable) {
       info = 'input_type_text';
     } else if (cvox.DomUtil.isMath(targetNode)) {
       info = 'math_expr';
-    } else if (targetNode.tagName == 'TABLE' &&
+    } else if (
+        targetNode.tagName == 'TABLE' &&
         cvox.DomUtil.isLayoutTable(targetNode)) {
       info = '';
     } else {
       if (verbosity == cvox.VERBOSITY_BRIEF) {
         info =
             cvox.DomUtil.TAG_TO_INFORMATION_TABLE_BRIEF_MSG[targetNode.tagName];
       } else {
-        info = cvox.DomUtil.TAG_TO_INFORMATION_TABLE_VERBOSE_MSG[
-          targetNode.tagName];
+        info = cvox.DomUtil
+                   .TAG_TO_INFORMATION_TABLE_VERBOSE_MSG[targetNode.tagName];
 
         if (cvox.DomUtil.hasLongDesc(targetNode)) {
           info = 'image_with_long_desc';
         }
 
         if (!info && targetNode.onclick) {
           info = 'clickable';
         }
       }
     }
   }
 
   return info;
 };
 
 
 /**
  * Returns a string to be presented to the user that identifies what the
  * targetNode's role is.
  * ARIA roles are given priority; if there is no ARIA role set, the role
  * will be determined by the HTML tag for the node.
  *
  * @param {Node} targetNode The node to get the role name for.
  * @param {number} verbosity The verbosity setting to use.
  * @return {string} The role name for the targetNode.
  */
 cvox.DomUtil.getRole = function(targetNode, verbosity) {
   var roleMsg = cvox.DomUtil.getRoleMsg(targetNode, verbosity) || '';
-  var role = roleMsg && roleMsg != ' ' ?
-      Msgs.getMsg(roleMsg) : '';
+  var role = roleMsg && roleMsg != ' ' ? Msgs.getMsg(roleMsg) : '';
   return role ? role : roleMsg;
 };
 
 
 /**
  * Count the number of items in a list node.
  *
  * @param {Node} targetNode The list node.
  * @return {number} The number of items in the list.
  */
 cvox.DomUtil.getListLength = function(targetNode) {
   var count = 0;
-  for (var node = targetNode.firstChild;
-       node;
-       node = node.nextSibling) {
+  for (var node = targetNode.firstChild; node; node = node.nextSibling) {
     if (cvox.DomUtil.isVisible(node) &&
         (node.tagName == 'LI' ||
-        (node.getAttribute && node.getAttribute('role') == 'listitem'))) {
+         (node.getAttribute && node.getAttribute('role') == 'listitem'))) {
       if (node.hasAttribute('aria-setsize')) {
         var ariaLength = parseInt(node.getAttribute('aria-setsize'), 10);
         if (!isNaN(ariaLength)) {
           return ariaLength;
         }
       }
       count++;
     }
   }
   return count;
@@ skipping 20 matching lines @@
   if (!info) {
     info = [];
   }
 
   if (targetNode.tagName == 'INPUT') {
     if (!targetNode.hasAttribute('aria-checked')) {
       var INPUT_MSGS = {
         'checkbox-true': 'checkbox_checked_state',
         'checkbox-false': 'checkbox_unchecked_state',
         'radio-true': 'radio_selected_state',
-        'radio-false': 'radio_unselected_state' };
+        'radio-false': 'radio_unselected_state'
+      };
       var msgId = INPUT_MSGS[targetNode.type + '-' + !!targetNode.checked];
       if (msgId) {
         info.push([msgId]);
       }
     }
   } else if (targetNode.tagName == 'SELECT') {
     if (targetNode.selectedOptions && targetNode.selectedOptions.length <= 1) {
-      info.push(['list_position',
-                 Msgs.getNumber(targetNode.selectedIndex + 1),
-                 Msgs.getNumber(targetNode.options.length)]);
+      info.push([
+        'list_position', Msgs.getNumber(targetNode.selectedIndex + 1),
+        Msgs.getNumber(targetNode.options.length)
+      ]);
     } else {
-      info.push(['selected_options_state',
-          Msgs.getNumber(targetNode.selectedOptions.length)]);
+      info.push([
+        'selected_options_state',
+        Msgs.getNumber(targetNode.selectedOptions.length)
+      ]);
     }
-  } else if (targetNode.tagName == 'UL' ||
-             targetNode.tagName == 'OL' ||
-             role == 'list') {
-    info.push(['list_with_items_not_pluralized',
-               Msgs.getNumber(
-                   cvox.DomUtil.getListLength(targetNode))]);
+  } else if (
+      targetNode.tagName == 'UL' || targetNode.tagName == 'OL' ||
+      role == 'list') {
+    info.push([
+      'list_with_items_not_pluralized',
+      Msgs.getNumber(cvox.DomUtil.getListLength(targetNode))
+    ]);
   }
 
   if (cvox.DomUtil.isDisabled(targetNode)) {
     info.push(['aria_disabled_true']);
   }
 
   if (targetNode.accessKey) {
     info.push(['access_key', targetNode.accessKey]);
   }
 
@@ skipping 37 matching lines @@
   // Workaround for http://code.google.com/p/chromium/issues/detail?id=153904
   if ((targetNode.tagName == 'A') && !targetNode.hasAttribute('href') &&
       !targetNode.hasAttribute('tabindex')) {
     return false;
   }
 
   if (targetNode.tabIndex >= 0) {
     return true;
   }
 
-  if (targetNode.hasAttribute &&
-      targetNode.hasAttribute('tabindex') &&
+  if (targetNode.hasAttribute && targetNode.hasAttribute('tabindex') &&
       targetNode.getAttribute('tabindex') == '-1') {
     return true;
   }
 
   return false;
 };
 
 
 /**
  * Find a focusable descendant of a given node. This includes nodes whose
@@ skipping 20 matching lines @@
 
 /**
  * Returns the number of focusable nodes in root's subtree. The count does not
  * include root.
  *
  * @param {Node} targetNode The node whose descendants to check are focusable.
  * @return {number} The number of focusable descendants.
  */
 cvox.DomUtil.countFocusableDescendants = function(targetNode) {
   return targetNode ?
-      cvox.DomUtil.countNodes(targetNode, cvox.DomUtil.isFocusable) : 0;
+      cvox.DomUtil.countNodes(targetNode, cvox.DomUtil.isFocusable) :
+      0;
 };
 
 
 /**
  * Checks if the targetNode is still attached to the document.
  * A node can become detached because of AJAX changes.
  *
  * @param {Object} targetNode The node to check.
  * @return {boolean} True if the targetNode is still attached.
  */
@@ skipping 49 matching lines @@
     if (!keepGoing) {
       // The onclick method ran successfully and returned false, meaning the
       // event should not bubble up, so we will return here.
       return;
     }
   }
 
   // Send a mousedown (or simply a double click if requested).
   var evt = document.createEvent('MouseEvents');
   var evtType = opt_double ? 'dblclick' : 'mousedown';
-  evt.initMouseEvent(evtType, true, true, document.defaultView,
-                     1, 0, 0, 0, 0, false, false, shiftKey, false, 0, null);
+  evt.initMouseEvent(
+      evtType, true, true, document.defaultView, 1, 0, 0, 0, 0, false, false,
+      shiftKey, false, 0, null);
   // Unless asked not to, Mark any events we generate so we don't try to
   // process our own events.
   evt.fromCvox = !opt_handleOwnEvents;
   try {
     targetNode.dispatchEvent(evt);
-  } catch (e) {}
-  //Send a mouse up
+  } catch (e) {
+  }
+  // Send a mouse up
   evt = document.createEvent('MouseEvents');
-  evt.initMouseEvent('mouseup', true, true, document.defaultView,
-                     1, 0, 0, 0, 0, false, false, shiftKey, false, 0, null);
+  evt.initMouseEvent(
+      'mouseup', true, true, document.defaultView, 1, 0, 0, 0, 0, false, false,
+      shiftKey, false, 0, null);
   evt.fromCvox = !opt_handleOwnEvents;
   try {
     targetNode.dispatchEvent(evt);
-  } catch (e) {}
-  //Send a click
+  } catch (e) {
+  }
+  // Send a click
   evt = document.createEvent('MouseEvents');
-  evt.initMouseEvent('click', true, true, document.defaultView,
-                     1, 0, 0, 0, 0, false, false, shiftKey, false, 0, null);
+  evt.initMouseEvent(
+      'click', true, true, document.defaultView, 1, 0, 0, 0, 0, false, false,
+      shiftKey, false, 0, null);
   evt.fromCvox = !opt_handleOwnEvents;
   try {
     targetNode.dispatchEvent(evt);
-  } catch (e) {}
+  } catch (e) {
+  }
 
   if (cvox.DomUtil.isInternalLink(targetNode)) {
     cvox.DomUtil.syncInternalLink(targetNode);
   }
 };
 
 
 /**
  * Syncs to an internal link.
  * @param {Node} node A link whose href's target we want to sync.
@@ skipping 53 matching lines @@
 /**
  * Given a node, returns true if it's a control. Controls are *not necessarily*
  * leaf-level given that some composite controls may have focusable children
  * if they are managing focus with tabindex:
  * ( http://www.w3.org/TR/2010/WD-wai-aria-practices-20100916/#visualfocus ).
  *
  * @param {Node} node The node to check.
  * @return {boolean} True if the node is a control.
  */
 cvox.DomUtil.isControl = function(node) {
-  if (cvox.AriaUtil.isControlWidget(node) &&
-      cvox.DomUtil.isFocusable(node)) {
+  if (cvox.AriaUtil.isControlWidget(node) && cvox.DomUtil.isFocusable(node)) {
     return true;
   }
   if (node.tagName) {
     switch (node.tagName) {
       case 'BUTTON':
       case 'TEXTAREA':
       case 'SELECT':
         return true;
       case 'INPUT':
         return node.type != 'hidden';
@@ skipping 10 matching lines @@
  * Given a node, returns true if it's a leaf-level control. This includes
  * composite controls thare are managing focus for children with
  * activedescendant, but not composite controls with focusable children:
  * ( http://www.w3.org/TR/2010/WD-wai-aria-practices-20100916/#visualfocus ).
  *
  * @param {Node} node The node to check.
  * @return {boolean} True if the node is a leaf-level control.
  */
 cvox.DomUtil.isLeafLevelControl = function(node) {
   if (cvox.DomUtil.isControl(node)) {
-    return !(cvox.AriaUtil.isCompositeControl(node) &&
-             cvox.DomUtil.findFocusableDescendant(node));
+    return !(
+        cvox.AriaUtil.isCompositeControl(node) &&
+        cvox.DomUtil.findFocusableDescendant(node));
   }
   return false;
 };
 
 
 /**
  * Given a node that might be inside of a composite control like a listbox,
  * return the surrounding control.
  * @param {Node} node The node from which to start looking.
  * @return {Node} The surrounding composite control node, or null if none.
  */
 cvox.DomUtil.getSurroundingControl = function(node) {
   var surroundingControl = null;
   if (!cvox.DomUtil.isControl(node) && node.hasAttribute &&
       node.hasAttribute('role')) {
     surroundingControl = node.parentElement;
     while (surroundingControl &&
-        !cvox.AriaUtil.isCompositeControl(surroundingControl)) {
+           !cvox.AriaUtil.isCompositeControl(surroundingControl)) {
       surroundingControl = surroundingControl.parentElement;
     }
   }
   return surroundingControl;
 };
 
 
 /**
  * Given a node and a function for determining when to stop
  * descent, return the next leaf-like node.
@@ skipping 11 matching lines @@
   if (node != document.body) {
     // if not at the top of the tree, we want to find the next possible
     // branch forward in the dom, so we climb up the parents until we find a
     // node that has a nextSibling
     while (!cvox.DomUtil.directedNextSibling(node, r)) {
       if (!node) {
         return null;
       }
       // since node is never above document.body, it always has a parent.
       // so node.parentNode will never be null.
-      node = /** @type {!Node} */(node.parentNode);
+      node = /** @type {!Node} */ (node.parentNode);
       if (node == document.body) {
         // we've readed the end of the document.
         return null;
       }
     }
     if (cvox.DomUtil.directedNextSibling(node, r)) {
       // we just checked that next sibling is non-null.
-      node = /** @type {!Node} */(cvox.DomUtil.directedNextSibling(node, r));
+      node = /** @type {!Node} */ (cvox.DomUtil.directedNextSibling(node, r));
     }
   }
   // once we're at our next sibling, we want to descend down into it as
   // far as the child class will allow
   while (cvox.DomUtil.directedFirstChild(node, r) && !isLeaf(node)) {
-    node = /** @type {!Node} */(cvox.DomUtil.directedFirstChild(node, r));
+    node = /** @type {!Node} */ (cvox.DomUtil.directedFirstChild(node, r));
   }
 
   // after we've done all that, if we are still at document.body, this must
   // be an empty document.
   if (node == document.body) {
     return null;
   }
   return node;
 };
 
@@ skipping 93 matching lines @@
   above = !!above;
   deep = !!deep;
   if (!cvox.DomUtil.isDescendantOfNode(node, ancestor) || node == ancestor) {
     return null;
   }
   var next = cvox.DomUtil.directedNextSibling(node, r);
   while (next) {
     if (!deep && pred(next)) {
       return next;
     }
-    var leaf = (deep ?
-                cvox.DomUtil.directedFindDeepestNode :
+    var leaf =
+        (deep ? cvox.DomUtil.directedFindDeepestNode :
                 cvox.DomUtil.directedFindFirstNode)(next, r, pred);
     if (leaf) {
       return leaf;
     }
     if (deep && pred(next)) {
       return next;
     }
     next = cvox.DomUtil.directedNextSibling(next, r);
   }
-  var parent = /** @type {!Node} */(node.parentNode);
+  var parent = /** @type {!Node} */ (node.parentNode);
   if (above && pred(parent)) {
     return parent;
   }
   return cvox.DomUtil.directedFindNextNode(
       parent, ancestor, r, pred, above, deep);
 };
 
 
 /**
  * Get a string representing a control's value and state, i.e. the part
  *     that changes while interacting with the control
  * @param {Element} control A control.
  * @return {string} The value and state string.
  */
 cvox.DomUtil.getControlValueAndStateString = function(control) {
   var parentControl = cvox.DomUtil.getSurroundingControl(control);
   if (parentControl) {
     return cvox.DomUtil.collapseWhitespace(
-        cvox.DomUtil.getValue(control) + ' ' +
-        cvox.DomUtil.getName(control) + ' ' +
-        cvox.DomUtil.getState(control, true));
+        cvox.DomUtil.getValue(control) + ' ' + cvox.DomUtil.getName(control) +
+        ' ' + cvox.DomUtil.getState(control, true));
   } else {
     return cvox.DomUtil.collapseWhitespace(
         cvox.DomUtil.getValue(control) + ' ' +
         cvox.DomUtil.getState(control, true));
   }
 };
 
 
 /**
  * Determine whether the given node is an internal link.
  * @param {Node} node The node to be examined.
  * @return {boolean} True if the node is an internal link, false otherwise.
  */
 cvox.DomUtil.isInternalLink = function(node) {
-  if (node.nodeType == 1) { // Element nodes only.
+  if (node.nodeType == 1) {  // Element nodes only.
     var href = node.getAttribute('href');
     if (href && href.indexOf('#') != -1) {
       var path = href.split('#')[0];
       return path == '' || path == window.location.pathname;
     }
   }
   return false;
 };
 
 
 /**
  * Get a string containing the currently selected link's URL.
  * @param {Node} node The link from which URL needs to be extracted.
  * @return {string} The value of the URL.
  */
 cvox.DomUtil.getLinkURL = function(node) {
   if (node.tagName == 'A') {
     if (node.getAttribute('href')) {
       if (cvox.DomUtil.isInternalLink(node)) {
         return Msgs.getMsg('internal_link');
       } else {
         return node.getAttribute('href');
       }
     } else {
       return '';
     }
-  } else if (cvox.AriaUtil.getRoleName(node) ==
-             Msgs.getMsg('role_link')) {
+  } else if (cvox.AriaUtil.getRoleName(node) == Msgs.getMsg('role_link')) {
     return Msgs.getMsg('unknown_link');
   }
 
   return '';
 };
 
 
 /**
  * Checks if a given node is inside a table and returns the table node if it is
  * @param {Node} node The node.
@@ skipping 38 matching lines @@
 
 /**
  * Determines whether a given table is a data table or a layout table
  * @param {Node} tableNode The table node.
  * @return {boolean} If the table is a layout table, returns true. False
  * otherwise.
  */
 cvox.DomUtil.isLayoutTable = function(tableNode) {
   // TODO(stoarca): Why are we returning based on this inaccurate heuristic
   // instead of first trying the better heuristics below?
-  if (tableNode.rows && (tableNode.rows.length <= 1 ||
-      (tableNode.rows[0].childElementCount == 1))) {
+  if (tableNode.rows &&
+      (tableNode.rows.length <= 1 ||
+       (tableNode.rows[0].childElementCount == 1))) {
     // This table has either 0 or one rows, or only "one" column.
     // This is a quick check for column count and may not be accurate. See
     // TraverseTable.getW3CColCount_ for a more accurate
     // (but more complicated) way to determine column count.
     return true;
   }
 
   // These heuristics are adapted from the Firefox data and layout table.
   // heuristics: http://asurkov.blogspot.com/2011/10/data-vs-layout-table.html
   if (cvox.AriaUtil.isGrid(tableNode)) {
@@ skipping 39 matching lines @@
   }
 
   // These heuristics are loosely based on Okada and Miura's "Detection of
   // Layout-Purpose TABLE Tags Based on Machine Learning" (2007).
   // http://books.google.com/books?id=kUbmdqasONwC&lpg=PA116&ots=Lb3HJ7dISZ&lr&pg=PA116
 
   // Increase the points for each heuristic. If there are 3 or more points,
   // this is probably a layout table.
   var points = 0;
 
-  if (! cvox.DomUtil.hasBorder(tableNode)) {
+  if (!cvox.DomUtil.hasBorder(tableNode)) {
     // This table has no border.
     points++;
   }
 
   if (tableNode.rows.length <= 6) {
     // This table has a limited number of rows.
     points++;
   }
 
   if (cvox.DomUtil.countPreviousTags(tableNode) <= 12) {
     // This table has a limited number of previous tags.
     points++;
   }
 
- if (cvox.XpathUtil.evalXPath('tbody/tr/td/table', tableNode).length > 0) {
-   // This table has nested tables.
-   points++;
- }
+  if (cvox.XpathUtil.evalXPath('tbody/tr/td/table', tableNode).length > 0) {
+    // This table has nested tables.
+    points++;
+  }
   return (points >= 3);
 };
 
 
 /**
  * Count previous tags, which we dfine as the number of HTML tags that
  * appear before the given node.
  * @param {Node} node The given node.
  * @return {number} The number of previous tags.
  */
@@ skipping 240 matching lines @@
 /**
  * Creates a function that sends a click. This is because loop closures
  * are dangerous.
  * See: http://joust.kano.net/weblog/archive/2005/08/08/
  * a-huge-gotcha-with-javascript-closures/
  * @param {Node} targetNode The target node to click on.
  * @return {function()} A function that will click on the given targetNode.
  */
 cvox.DomUtil.createSimpleClickFunction = function(targetNode) {
   var target = targetNode.cloneNode(true);
-  return function() { cvox.DomUtil.clickElem(target, false, false); };
+  return function() {
+    cvox.DomUtil.clickElem(target, false, false);
+  };
 };
 
 /**
  * Adds a node to document.head if that node has not already been added.
  * If document.head does not exist, this will add the node to the body.
  * @param {Node} node The node to add.
  * @param {string=} opt_id The id of the node to ensure the node is only
  *     added once.
  */
 cvox.DomUtil.addNodeToHead = function(node, opt_id) {
   if (opt_id && document.getElementById(opt_id)) {
-      return;
+    return;
   }
   var p = document.head || document.body;
   p.appendChild(node);
 };
 
 
 /**
  * Checks if a given node is inside a math expressions and
  * returns the math node if one exists.
  * @param {Node} node The node.
@@ skipping 21 matching lines @@
   return null;
 };
 
 
 /**
  * Checks to see wether a node is a math node.
  * @param {Node} node The node to be tested.
  * @return {boolean} Whether or not a node is a math node.
  */
 cvox.DomUtil.isMath = function(node) {
-  return cvox.DomUtil.isMathml(node) ||
-      cvox.DomUtil.isMathJax(node) ||
-          cvox.DomUtil.isMathImg(node) ||
-              cvox.AriaUtil.isMath(node);
+  return cvox.DomUtil.isMathml(node) || cvox.DomUtil.isMathJax(node) ||
+      cvox.DomUtil.isMathImg(node) || cvox.AriaUtil.isMath(node);
 };
 
 
 /**
  * Specifies node classes in which we expect maths expressions a alt text.
  * @type {{tex: Array<string>,
  *         asciimath: Array<string>}}
  */
 // These are the classes for which we assume they contain Maths in the ALT or
 // TITLE attribute.
 // tex: Wikipedia;
 // latex: Wordpress;
 // numberedequation, inlineformula, displayformula: MathWorld;
 cvox.DomUtil.ALT_MATH_CLASSES = {
   tex: ['tex', 'latex'],
   asciimath: ['numberedequation', 'inlineformula', 'displayformula']
 };
 
 
 /**
  * Composes a query selector string for image nodes with alt math content by
  * type of content.
  * @param {string} contentType The content type, e.g., tex, asciimath.
  * @return {!string} The query elector string.
  */
 cvox.DomUtil.altMathQuerySelector = function(contentType) {
   var classes = cvox.DomUtil.ALT_MATH_CLASSES[contentType];
   if (classes) {
-    return classes.map(function(x) {return 'img.' + x;}).join(', ');
+    return classes
+        .map(function(x) {
+          return 'img.' + x;
+        })
+        .join(', ');
   }
   return '';
 };
 
 
 /**
  * Check if a given node is potentially a math image with alternative text in
  * LaTeX.
  * @param {Node} node The node to be tested.
  * @return {boolean} Whether or not a node has an image with class TeX or LaTeX.
@@ skipping 34 matching lines @@
  * Checks to see wether a node is a MathJax node.
  * @param {Node} node The node to be tested.
  * @return {boolean} Whether or not a node is a MathJax node.
  */
 cvox.DomUtil.isMathJax = function(node) {
   if (!node || !node.tagName || !node.className) {
     return false;
   }
 
   function isSpanWithClass(n, cl) {
-    return (n.tagName == 'SPAN' &&
-            n.className.split(' ').some(function(x) {
-                                          return x.toLowerCase() == cl;}));
+    return (n.tagName == 'SPAN' && n.className.split(' ').some(function(x) {
+      return x.toLowerCase() == cl;
+    }));
   }
   if (isSpanWithClass(node, 'math')) {
     var ancestors = cvox.DomUtil.getAncestors(node);
-    return ancestors.some(function(x) {return isSpanWithClass(x, 'mathjax');});
+    return ancestors.some(function(x) {
+      return isSpanWithClass(x, 'mathjax');
+    });
   }
   return false;
 };
 
 
 /**
  * Computes the id of the math span in a MathJax DOM element.
  * @param {string} jaxId The id of the MathJax node.
  * @return {string} The id of the span node.
  */
@@ skipping 34 matching lines @@
   return '';
 };
 
 
 /**
  * Cleaning up a list of nodes to remove empty text nodes.
  * @param {NodeList} nodes The nodes list.
  * @return {!Array<Node|string|null>} The cleaned up list of nodes.
  */
 cvox.DomUtil.purgeNodes = function(nodes) {
-  return cvox.DomUtil.toArray(nodes).
-      filter(function(node) {
-               return node.nodeType != Node.TEXT_NODE ||
-                   !node.textContent.match(/^\s+$/);});
+  return cvox.DomUtil.toArray(nodes).filter(function(node) {
+    return node.nodeType != Node.TEXT_NODE || !node.textContent.match(/^\s+$/);
+  });
 };
 
 
 /**
  * Calculates a hit point for a given node.
  * @param {Node} node The given node.
  * @return {{x:(number), y:(number)}} The position.
  */
 cvox.DomUtil.elementToPoint = function(node) {
   if (!node) {
     return {x: 0, y: 0};
   }
   if (node.constructor == Text) {
     node = node.parentNode;
   }
   var r = node.getBoundingClientRect();
-  return {
-    x: r.left + (r.width / 2),
-    y: r.top + (r.height / 2)
-  };
+  return {x: r.left + (r.width / 2), y: r.top + (r.height / 2)};
 };
 
 
 /**
  * Checks if an input node supports HTML5 selection.
  * If the node is not an input element, returns false.
  * @param {Node} node The node to check.
  * @return {boolean} True if HTML5 selection supported.
  */
 cvox.DomUtil.doesInputSupportSelection = function(node) {
-  return goog.isDef(node) &&
-      node.tagName == 'INPUT' &&
-      node.type != 'email' &&
+  return goog.isDef(node) && node.tagName == 'INPUT' && node.type != 'email' &&
       node.type != 'number';
 };
 
 
 /**
  * Gets the hint text for a given element.
  * @param {Node} node The target node.
  * @return {string} The hint text.
  */
 cvox.DomUtil.getHint = function(node) {
   var desc = '';
   if (node.hasAttribute) {
     if (node.hasAttribute('aria-describedby')) {
       var describedByIds = node.getAttribute('aria-describedby').split(' ');
       for (var describedById, i = 0; describedById = describedByIds[i]; i++) {
         var describedNode = document.getElementById(describedById);
         if (describedNode) {
-          desc += ' ' + cvox.DomUtil.getName(
-              describedNode, true, true, true);
+          desc += ' ' + cvox.DomUtil.getName(describedNode, true, true, true);
         }
       }
     }
   }
   return desc;
 };