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

chrome/browser/resources/chromeos/chromevox/cvox2/background/automation_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 ChromeVox utilities for the automation extension API.
  */
 
 goog.provide('AutomationUtil');
 
@@ skipping 24 matching lines @@
     return null;
 
   if (pred(cur) && !AutomationPredicate.shouldIgnoreNode(cur))
     return cur;
 
   var child = dir == Dir.BACKWARD ? cur.lastChild : cur.firstChild;
   while (child) {
     var ret = AutomationUtil.findNodePre(child, dir, pred);
     if (ret)
       return ret;
-    child = dir == Dir.BACKWARD ?
-        child.previousSibling : child.nextSibling;
+    child = dir == Dir.BACKWARD ? child.previousSibling : child.nextSibling;
   }
   return null;
 };
 
 /**
  * Find a node in subtree of |cur| satisfying |pred| using post-order traversal.
  * @param {AutomationNode} cur Node to begin the search from.
  * @param {Dir} dir
  * @param {AutomationPredicate.Unary} pred A predicate to apply
  *     to a candidate node.
  * @return {AutomationNode}
  */
 AutomationUtil.findNodePost = function(cur, dir, pred) {
   if (!cur)
     return null;
 
   var child = dir == Dir.BACKWARD ? cur.lastChild : cur.firstChild;
   while (child) {
     var ret = AutomationUtil.findNodePost(child, dir, pred);
     if (ret)
       return ret;
-    child = dir == Dir.BACKWARD ?
-        child.previousSibling : child.nextSibling;
+    child = dir == Dir.BACKWARD ? child.previousSibling : child.nextSibling;
   }
 
   if (pred(cur) && !AutomationPredicate.shouldIgnoreNode(cur))
     return cur;
 
   return null;
 };
 
 /**
  * Find the next node in the given direction in depth first order.
@@ skipping 14 matching lines @@
  *     By default:
  *        the root predicate ges set to |AutomationPredicate.root|.
  *        |skipInitialSubtree| is false if |cur| is a container or matches
  *        |pred|. This alleviates the caller from syncing forwards.
  *        Leaves are nodes matched by |prred| which are not also containers.
  *        This takes care of syncing backwards.
  * @return {AutomationNode}
  */
 AutomationUtil.findNextNode = function(cur, dir, pred, opt_restrictions) {
   var restrictions = {};
-  opt_restrictions = opt_restrictions || {leaf: undefined,
-      root: undefined,
-      visit: undefined,
-      skipInitialSubtree: !AutomationPredicate.container(cur) && pred(cur)};
+  opt_restrictions = opt_restrictions || {
+    leaf: undefined,
+    root: undefined,
+    visit: undefined,
+    skipInitialSubtree: !AutomationPredicate.container(cur) && pred(cur)
+  };
 
   restrictions.root = opt_restrictions.root || AutomationPredicate.root;
   restrictions.leaf = opt_restrictions.leaf || function(node) {
     // Treat nodes matched by |pred| as leaves except for containers.
     return !AutomationPredicate.container(node) && pred(node);
   };
 
   restrictions.skipInitialSubtree = opt_restrictions.skipInitialSubtree;
   restrictions.skipInitialAncestry = opt_restrictions.skipInitialAncestry;
 
@@ skipping 163 matching lines @@
 /**
  * Gets a top level root.
  * @param {!AutomationNode} node
  * @return {AutomationNode}
  */
 AutomationUtil.getTopLevelRoot = function(node) {
   var root = node.root;
   if (!root || root.role == RoleType.DESKTOP)
     return null;
 
-  while (root &&
-      root.parent &&
-      root.parent.root &&
-      root.parent.root.role != RoleType.DESKTOP) {
+  while (root && root.parent && root.parent.root &&
+         root.parent.root.role != RoleType.DESKTOP) {
     root = root.parent.root;
   }
   return root;
 };
 
 /**
  * @param {!AutomationNode} prevNode
  * @param {!AutomationNode} node
  * @return {AutomationNode}
  */
@@ skipping 16 matching lines @@
 AutomationUtil.getText = function(node) {
   if (!node)
     return '';
 
   if (node.role === RoleType.TEXT_FIELD)
     return node.value || '';
   return node.name || '';
 };
 
 });  // goog.scope