Initial support for Ranges over automation nodes (used to track ChromeVox focus).

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');
 goog.provide('AutomationUtil.Dir');
@@ skipping 12 matching lines @@
 AutomationUtil.Dir = {
   // Search from left to right.
   FORWARD: 'forward',
 
   // Search from right to left.
   BACKWARD: 'backward'
 };
 
 
 goog.scope(function() {
+var AutomationNode = chrome.automation.AutomationNode;
 var Dir = AutomationUtil.Dir;
 
 /**
  * Find a node in subtree of |cur| satisfying |pred| using pre-order traversal.
  * @param {chrome.automation.AutomationNode} cur Node to begin the search from.

[dmazzoni, 2014/10/17 16:46:08]

Please replace all chrome.automation.AutomationNode with AutomationNode now that
you're adding it to scope.

  * @param {Dir} dir
  * @param {AutomationPredicate.Unary} pred A predicate to apply
  *     to a candidate node.
  * @return {chrome.automation.AutomationNode}
  */
 AutomationUtil.findNodePre = function(cur, dir, pred) {
   if (pred(cur))
     return cur;
 
   var child = dir == Dir.BACKWARD ? cur.lastChild() : cur.firstChild();
@@ skipping 99 matching lines @@
         prev = candidate;
         if (!satisfied)
           before = candidate;
         else
           after = candidate;
         return satisfied;
     });
   return opt_options.before ? before : after;
 };
 
+
+/**
+ * Returns ancestors of the given node (inclusive).

[dmazzoni, 2014/10/17 16:46:08]

Specify the order in which it returns the ancestors - from current node to root,
or from root to node?

[Peter Lundblad, 2014/10/23 13:35:07]

If order is guaranteed, specify that.

+ * @param {!AutomationNode} node
+ * @return {Array.<AutomationNode>}
+ */
+AutomationUtil.getAncestors = function(node) {

[Peter Lundblad, 2014/10/23 13:35:07]

nit: consider calling getAncestorsAndSelf or something that makes the
inclusive aspect clear (I know it's verbose).

+  var result = [node];
+  var target = node;
+  while (target = target.parent())
+    result.push(target);
+  return result;
+};
+
+/**
+ * Returns whether |first| comes before |second| in Dir.FORWARD traversal.

[Peter Lundblad, 2014/10/23 13:35:07]

Should specify if that this is not strict.

+ * @param {!AutomationNode} first
+ * @param {!AutomationNode} second
+ * @return {boolean}
+ */
+AutomationUtil.isBefore = function(first, second) {

[dmazzoni, 2014/10/17 16:46:08]

How about a unit test for this?

I think it's worth taking the time to write a test...we need this type of
function to be testable - maybe a concise way to create mock AutomationNode
trees for tests, maybe from JSON?

+  if (first === second)
+    return true;
+
+  var firstA = AutomationUtil.getAncestors(first);
+  var secondA = AutomationUtil.getAncestors(second);
+  var lcaIndex;

[Peter Lundblad, 2014/10/23 13:35:07]

What does 'lca' mean?

+  for (var i = firstA.length - 1, j = secondA.length - 1;
+       firstA[i] === secondA[j];
+       i--, j--)
+    lcaIndex = [i, j];
+
+  if (lcaIndex) {
+    var firstC = firstA[lcaIndex[0] - 1];
+    var secondC = secondA[lcaIndex[1] - 1];
+    var firstCount = 0, secondCount = 0;
+    // TODO(dtseng): Expose parent in index (chrome.automation.AutomationNode).

[dmazzoni, 2014/10/17 16:46:08]

How about writing an indexInParent helper, which could be eliminated once it's
exposed? That seems more foolproof, you don't have to think about this logic
again later.

+    while (firstC = firstC.nextSibling()) firstCount++;
+      firstCount++;

[Peter Lundblad, 2014/10/23 13:35:07]

Looks like one increment too much here.

+    while (secondC = secondC.nextSibling())
+      secondCount++;
+    return firstCount <= secondCount;
+  }
+};

[Peter Lundblad, 2014/10/23 13:35:07]

This function is unnecessarily cryptic because of the short names.

+
 });  // goog.scope