Cleanup AutomationUtil.findNodeUntil, fix wrapping when moving by line,

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 97 matching lines @@
       return true;
   };
 
   var walker = new AutomationTreeWalker(cur, dir, restrictions);
   return walker.next().node;
 };
 
 /**
  * Given nodes a_1, ..., a_n starting at |cur| in pre order traversal, apply
  * |pred| to a_i and a_(i - 1) until |pred| is satisfied.  Returns a_(i - 1) or
- * a_i (depending on opt_options.before) or null if no match was found.
+ * a_i (depending on opt_before) or null if no match was found.
  * @param {!AutomationNode} cur
  * @param {Dir} dir
  * @param {AutomationPredicate.Binary} pred
- * @param {{filter: (AutomationPredicate.Unary|undefined),
- *      before: boolean?}=} opt_options
- *     filter - Filters which candidate nodes to consider. Defaults to leaf
- *         only.
- *     before - True to return a_(i - 1); a_i otherwise. Defaults to false.
+ * @param {boolean=} opt_before True to return a_(i - 1); a_i otherwise.
+ *                              Defaults to false.
  * @return {AutomationNode}
  */
-AutomationUtil.findNodeUntil = function(cur, dir, pred, opt_options) {
-  opt_options =
-      opt_options || {filter: AutomationPredicate.leaf, before: false};
-  if (!opt_options.filter)
-    opt_options.filter = AutomationPredicate.leaf;
-
-  var before = null;
-  var after = null;
-  var prev = cur;
-  AutomationUtil.findNextNode(cur,
-      dir,
-      function(candidate) {
-        if (!opt_options.filter(candidate))
-          return false;
-
-        var satisfied = pred(prev, candidate);
-
-        prev = candidate;
-        if (!satisfied)
-          before = candidate;
-        else
-          after = candidate;
-        return satisfied;
-      },
-      {leaf: AutomationPredicate.leaf, skipInitialSubtree: true});
-
-  return opt_options.before ? before : after;
+AutomationUtil.findNodeUntil = function(cur, dir, pred, opt_before) {
+  var before = cur;
+  var after = before;
+  do {
+    before = after;
+    after = AutomationUtil.findNextNode(before, dir, AutomationPredicate.leaf);
+  } while (after && !pred(before, after));
+  return opt_before ? before : after;
 };
 
 /**
  * Returns an array containing ancestors of node starting at root down to node.
  * @param {!AutomationNode} node
  * @return {!Array<AutomationNode>}
  */
 AutomationUtil.getAncestors = function(node) {
   var ret = [];
   var candidate = node;
@@ skipping 115 matching lines @@
     a = a.parent.root;
 
   b = b.root;
   while (b && b.parent && AutomationUtil.isInSameTree(b.parent, b))
     b = b.parent.root;
 
   return a == b;
 };
 
 });  // goog.scope