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

chrome/browser/resources/chromeos/chromevox/common/traverse_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 Low-level DOM traversal utility functions to find the
  *     next (or previous) character, word, sentence, line, or paragraph,
  *     in a completely stateless manner without actually manipulating the
  *     selection.
  */
@@ skipping 29 matching lines @@
  * its children are properties of the object that shouldn't be traversed.
  *
  * TODO(dmazzoni): replace this with a predicate that detects nodes with
  * ARIA roles and other objects that have their own description.
  * For now we just detect a couple of common cases.
  *
  * @param {Node} node A DOM node.
  * @return {boolean} True if the node should be treated as a leaf node.
  */
 cvox.TraverseUtil.treatAsLeafNode = function(node) {
-  return node.childNodes.length == 0 ||
-         node.nodeName == 'SELECT' ||
-         node.getAttribute('role') == 'listbox' ||
-         node.nodeName == 'OBJECT';
+  return node.childNodes.length == 0 || node.nodeName == 'SELECT' ||
+      node.getAttribute('role') == 'listbox' || node.nodeName == 'OBJECT';
 };
 
 /**
  * Return true only if a single character is whitespace.
  * From https://developer.mozilla.org/en/Whitespace_in_the_DOM,
  * whitespace is defined as one of the characters
  *  "\t" TAB \u0009
  *  "\n" LF  \u000A
  *  "\r" CR  \u000D
  *  " "  SPC \u0020.
@@ skipping 83 matching lines @@
     }
 
     // Return the next character from this leaf node.
     if (cursor.index < cursor.text.length)
       return cursor.text[cursor.index++];
 
     // Move to the next sibling, going up the tree as necessary.
     while (cursor.node != null) {
       // Try to move to the next sibling.
       var siblingNode = null;
-      for (var node = cursor.node.nextSibling;
-           node != null;
+      for (var node = cursor.node.nextSibling; node != null;
            node = node.nextSibling) {
         if (cvox.TraverseUtil.isHidden(node)) {
           if (node instanceof HTMLElement) {
             elementsEntered.push(node);
           }
           continue;
         }
         if (cvox.DomUtil.isVisible(node, {checkAncestors: false})) {
           siblingNode = node;
           break;
@@ skipping 76 matching lines @@
 
     // Return the previous character from this leaf node.
     if (cursor.text.length > 0 && cursor.index > 0) {
       return cursor.text[--cursor.index];
     }
 
     // Move to the previous sibling, going up the tree as necessary.
     while (true) {
       // Try to move to the previous sibling.
       var siblingNode = null;
-      for (var node = cursor.node.previousSibling;
-           node != null;
+      for (var node = cursor.node.previousSibling; node != null;
            node = node.previousSibling) {
         if (cvox.TraverseUtil.isHidden(node)) {
           if (node instanceof HTMLElement) {
             elementsEntered.push(node);
           }
           continue;
         }
         if (cvox.DomUtil.isVisible(node, {checkAncestors: false})) {
           siblingNode = node;
           break;
@@ skipping 49 matching lines @@
  * @param {boolean} skipWhitespace If true, will keep scanning until a
  *     non-whitespace character is found.
  * @return {?string} The next char, or null if the bottom of the
  *     document has been reached.
  */
 cvox.TraverseUtil.getNextChar = function(
     startCursor, endCursor, elementsEntered, elementsLeft, skipWhitespace) {
 
   // Save the starting position and get the first character.
   startCursor.copyFrom(endCursor);
-  var c = cvox.TraverseUtil.forwardsChar(
-      endCursor, elementsEntered, elementsLeft);
+  var c =
+      cvox.TraverseUtil.forwardsChar(endCursor, elementsEntered, elementsLeft);
   if (c == null)
     return null;
 
   // Keep track of whether the first character was whitespace.
   var initialWhitespace = cvox.TraverseUtil.isWhitespace(c);
 
   // Keep scanning until we find a non-whitespace or non-skipped character.
   while ((cvox.TraverseUtil.isWhitespace(c)) ||
-      (cvox.TraverseUtil.isHidden(endCursor.node))) {
+         (cvox.TraverseUtil.isHidden(endCursor.node))) {
     c = cvox.TraverseUtil.forwardsChar(
         endCursor, elementsEntered, elementsLeft);
     if (c == null)
       return null;
   }
   if (skipWhitespace || !initialWhitespace) {
     // If skipWhitepace is true, or if the first character we encountered
     // was not whitespace, return that non-whitespace character.
     startCursor.copyFrom(endCursor);
     startCursor.index--;
     return c;
-  }
-  else {
+  } else {
     for (var i = 0; i < elementsEntered.length; i++) {
       if (cvox.TraverseUtil.isHidden(elementsEntered[i])) {
         // We need to make sure that startCursor and endCursor aren't
         // surrounding a skippable node.
         endCursor.index--;
         startCursor.copyFrom(endCursor);
         startCursor.index--;
         return ' ';
       }
     }
@@ skipping 29 matching lines @@
   var c = cvox.TraverseUtil.backwardsChar(
       startCursor, elementsEntered, elementsLeft);
   if (c == null)
     return null;
 
   // Keep track of whether the first character was whitespace.
   var initialWhitespace = cvox.TraverseUtil.isWhitespace(c);
 
   // Keep scanning until we find a non-whitespace or non-skipped character.
   while ((cvox.TraverseUtil.isWhitespace(c)) ||
-      (cvox.TraverseUtil.isHidden(startCursor.node))) {
+         (cvox.TraverseUtil.isHidden(startCursor.node))) {
     c = cvox.TraverseUtil.backwardsChar(
         startCursor, elementsEntered, elementsLeft);
     if (c == null)
       return null;
   }
   if (skipWhitespace || !initialWhitespace) {
     // If skipWhitepace is true, or if the first character we encountered
     // was not whitespace, return that non-whitespace character.
     endCursor.copyFrom(startCursor);
     endCursor.index++;
@@ skipping 19 matching lines @@
  * a string of 1 or more non-whitespace characters in the same DOM node.
  * @param {cvox.Cursor} startCursor On exit, will point to the beginning of the
  *     word returned.
  * @param {cvox.Cursor} endCursor The position to start searching for the next
  *     word.  On exit, will point to the end of the word returned.
  * @param {Array<Element>} elementsEntered Any HTML elements entered.
  * @param {Array<Element>} elementsLeft Any HTML elements left.
  * @return {?string} The next word, or null if the bottom of the
  *     document has been reached.
  */
-cvox.TraverseUtil.getNextWord = function(startCursor, endCursor,
-    elementsEntered, elementsLeft) {
+cvox.TraverseUtil.getNextWord = function(
+    startCursor, endCursor, elementsEntered, elementsLeft) {
 
   // Find the first non-whitespace or non-skipped character.
   var cursor = endCursor.clone();
   var c = cvox.TraverseUtil.forwardsChar(cursor, elementsEntered, elementsLeft);
   if (c == null)
     return null;
   while ((cvox.TraverseUtil.isWhitespace(c)) ||
-      (cvox.TraverseUtil.isHidden(cursor.node))) {
+         (cvox.TraverseUtil.isHidden(cursor.node))) {
     c = cvox.TraverseUtil.forwardsChar(cursor, elementsEntered, elementsLeft);
     if (c == null)
       return null;
   }
 
   // Set startCursor to the position immediately before the first
   // character in our word. It's safe to decrement |index| because
   // forwardsChar guarantees that the cursor will be immediately to the
   // right of the returned character on exit.
   startCursor.copyFrom(cursor);
   startCursor.index--;
 
   // Keep building up our word until we reach a whitespace character or
   // would cross a tag.  Don't actually return any tags crossed, because this
   // word goes up until the tag boundary but not past it.
   endCursor.copyFrom(cursor);
   var word = c;
   var newEntered = [];
   var newLeft = [];
   c = cvox.TraverseUtil.forwardsChar(cursor, newEntered, newLeft);
   if (c == null) {
     return word;
   }
-  while (!cvox.TraverseUtil.isWhitespace(c) &&
-         newEntered.length == 0 &&
+  while (!cvox.TraverseUtil.isWhitespace(c) && newEntered.length == 0 &&
          newLeft == 0) {
     word += c;
     endCursor.copyFrom(cursor);
     c = cvox.TraverseUtil.forwardsChar(cursor, newEntered, newLeft);
     if (c == null) {
       return word;
     }
   }
 
   return word;
 };
 
 /**
  * Finds the previous word, starting from startCursor.  Upon exit, startCursor
  * and endCursor will surround the previous word.  A word is defined to be
  * a string of 1 or more non-whitespace characters in the same DOM node.
  * @param {cvox.Cursor} startCursor The position to start searching for the
  *     previous word.  On exit, will point to the beginning of the
  *     word returned.
  * @param {cvox.Cursor} endCursor On exit, will point to the end of the
  *     word returned.
  * @param {Array<Element>} elementsEntered Any HTML elements entered.
  * @param {Array<Element>} elementsLeft Any HTML elements left.
  * @return {?string} The previous word, or null if the bottom of the
  *     document has been reached.
  */
-cvox.TraverseUtil.getPreviousWord = function(startCursor, endCursor,
-    elementsEntered, elementsLeft) {
+cvox.TraverseUtil.getPreviousWord = function(
+    startCursor, endCursor, elementsEntered, elementsLeft) {
   // Find the first non-whitespace or non-skipped character.
   var cursor = startCursor.clone();
-  var c = cvox.TraverseUtil.backwardsChar(
-      cursor, elementsEntered, elementsLeft);
+  var c =
+      cvox.TraverseUtil.backwardsChar(cursor, elementsEntered, elementsLeft);
   if (c == null)
     return null;
-  while ((cvox.TraverseUtil.isWhitespace(c) ||
-      (cvox.TraverseUtil.isHidden(cursor.node)))) {
+  while (
+      (cvox.TraverseUtil.isWhitespace(c) ||
+       (cvox.TraverseUtil.isHidden(cursor.node)))) {
     c = cvox.TraverseUtil.backwardsChar(cursor, elementsEntered, elementsLeft);
     if (c == null)
       return null;
   }
 
   // Set endCursor to the position immediately after the first
   // character we've found (the last character of the word, since we're
   // searching backwards).
   endCursor.copyFrom(cursor);
   endCursor.index++;
 
   // Keep building up our word until we reach a whitespace character or
   // would cross a tag.  Don't actually return any tags crossed, because this
   // word goes up until the tag boundary but not past it.
   startCursor.copyFrom(cursor);
   var word = c;
   var newEntered = [];
   var newLeft = [];
   c = cvox.TraverseUtil.backwardsChar(cursor, newEntered, newLeft);
   if (c == null)
     return word;
-  while (!cvox.TraverseUtil.isWhitespace(c) &&
-         newEntered.length == 0 &&
+  while (!cvox.TraverseUtil.isWhitespace(c) && newEntered.length == 0 &&
          newLeft.length == 0) {
     word = c + word;
     startCursor.copyFrom(cursor);
 
     c = cvox.TraverseUtil.backwardsChar(cursor, newEntered, newLeft);
     if (c == null)
       return word;
   }
 
   return word;
@@ skipping 99 matching lines @@
  *     break the line.
  * @return {?string} The next line, or null if the bottom of the
  *     document has been reached.
  */
 cvox.TraverseUtil.getNextLine = function(
     startCursor, endCursor, elementsEntered, elementsLeft, breakTags) {
   var range = document.createRange();
   var currentRect = null;
   var rightMostRect = null;
   var prevCursor = endCursor.clone();
- return cvox.TraverseUtil.getNextString(
+  return cvox.TraverseUtil.getNextString(
       startCursor, endCursor, elementsEntered, elementsLeft,
       function(str, word, elementsEntered, elementsLeft) {
         range.setStart(startCursor.node, startCursor.index);
         range.setEnd(endCursor.node, endCursor.index);
         var currentRect = range.getBoundingClientRect();
         if (!rightMostRect) {
           rightMostRect = currentRect;
         }
 
         // Break at new lines except when within a link.
         if (currentRect.bottom != rightMostRect.bottom &&
-            !cvox.DomPredicates.linkPredicate(cvox.DomUtil.getAncestors(
-                endCursor.node))) {
+            !cvox.DomPredicates.linkPredicate(
+                cvox.DomUtil.getAncestors(endCursor.node))) {
           endCursor.copyFrom(prevCursor);
           return true;
         }
 
         rightMostRect = currentRect;
         prevCursor.copyFrom(endCursor);
 
         return cvox.TraverseUtil.includesBreakTagOrSkippedNode(
             elementsEntered, elementsLeft, breakTags);
       });
@@ skipping 24 matching lines @@
       function(str, word, elementsEntered, elementsLeft) {
         range.setStart(startCursor.node, startCursor.index);
         range.setEnd(endCursor.node, endCursor.index);
         var currentRect = range.getBoundingClientRect();
         if (!leftMostRect) {
           leftMostRect = currentRect;
         }
 
         // Break at new lines except when within a link.
         if (currentRect.top != leftMostRect.top &&
-            !cvox.DomPredicates.linkPredicate(cvox.DomUtil.getAncestors(
-                startCursor.node))) {
+            !cvox.DomPredicates.linkPredicate(
+                cvox.DomUtil.getAncestors(startCursor.node))) {
           startCursor.copyFrom(prevCursor);
           return true;
         }
 
         leftMostRect = currentRect;
         prevCursor.copyFrom(startCursor);
 
         return cvox.TraverseUtil.includesBreakTagOrSkippedNode(
             elementsEntered, elementsLeft, breakTags);
       });
 };
 
 /**
  * Finds the next paragraph, starting from endCursor.  Upon exit,
  * startCursor and endCursor will surround the next paragraph.
  *
  * @param {cvox.Cursor} startCursor On exit, marks the beginning of the
  *     paragraph.
  * @param {cvox.Cursor} endCursor The position to start searching for the next
  *     paragraph.  On exit, will point to the end of the returned string.
  * @param {Array<Element>} elementsEntered Any HTML elements entered.
  * @param {Array<Element>} elementsLeft Any HTML elements left.
  * @return {?string} The next paragraph, or null if the bottom of the
  *     document has been reached.
  */
-cvox.TraverseUtil.getNextParagraph = function(startCursor, endCursor,
-    elementsEntered, elementsLeft) {
+cvox.TraverseUtil.getNextParagraph = function(
+    startCursor, endCursor, elementsEntered, elementsLeft) {
   return cvox.TraverseUtil.getNextString(
       startCursor, endCursor, elementsEntered, elementsLeft,
       function(str, word, elementsEntered, elementsLeft) {
         for (var i = 0; i < elementsEntered.length; i++) {
           if (cvox.TraverseUtil.isHidden(elementsEntered[i])) {
             return true;
           }
           var style = window.getComputedStyle(elementsEntered[i], null);
           if (style && style.display != 'inline') {
             return true;
@@ skipping 169 matching lines @@
     newEntered = [];
     newLeft = [];
     word = cvox.TraverseUtil.getPreviousWord(
         wordStartCursor, wordEndCursor, newEntered, newLeft);
     if (word == null)
       return str;
   }
 
   return str;
 };