Refine ChromeVox's treatment of containers

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 59 matching lines @@
   }
 
   if (pred(cur))
     return cur;
 
   return null;
 };
 
 /**
  * Find the next node in the given direction in depth first order.
+ *
+ * Let D be the dfs linearization of |cur.root|. Then, let F be the list after
+ * applying |pred| as a filter to D. This method will return the directed next
+ * node of |cur| in F.
+ * The restrictions option will further filter F. For example,
+ * |skipInitialSubtree| will remove any |pred| matches in the subtree of |cur|
+ * from F.
  * @param {!AutomationNode} cur Node to begin the search from.
  * @param {Dir} dir
  * @param {AutomationPredicate.Unary} pred A predicate to apply
  *     to a candidate node.
  * @param {AutomationTreeWalkerRestriction=} opt_restrictions |leaf|, |root|,
- *     and |skipInitialSubtree| are valid restrictions used when finding the
- *     next node. If not supplied, the leaf predicate returns true for nodes
- *     matched by |pred| or |AutomationPredicate.container|. This is typically
- *     desirable in most situations.
- *     If not supplied, the root predicate gets set to
- *     |AutomationUtil.isTraversalRoot|.
+ *     |skipInitialAncestry|, and |skipInitialSubtree| are valid restrictions
+ *     used when finding the next node.
+ *     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)};
+      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.root = opt_restrictions.root || AutomationUtil.isTraversalRoot;
   restrictions.skipInitialSubtree = opt_restrictions.skipInitialSubtree;
   restrictions.skipInitialAncestry = opt_restrictions.skipInitialAncestry;
 
   restrictions.visit = function(node) {
-    if (pred(node) && !AutomationPredicate.shouldIgnoreLeaf(node))
-      return true;
-    if (AutomationPredicate.container(node))
-      return true;
+    return pred(node) && !AutomationPredicate.shouldIgnoreNode(node);
   };
 
   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_before) or null if no match was found.
@@ skipping 96 matching lines @@
 AutomationUtil.isInSameTree = function(a, b) {
   if (!a || !b)
     return true;
 
   // Given two non-desktop roots, consider them in the "same" tree.
   return a.root === b.root ||
       (a.root.role == b.root.role && a.root.role == RoleType.rootWebArea);
 };
 
 /**
- * Returns whether the given node should not be crossed when performing
- * traversals up the ancestry chain.
- * @param {AutomationNode} node
- * @return {boolean}
- */
-AutomationUtil.isTraversalRoot = function(node) {
-  switch (node.role) {
-    case RoleType.dialog:
-    case RoleType.window:
-      return true;
-    case RoleType.toolbar:
-      return node.root.role == RoleType.desktop;
-    case RoleType.rootWebArea:
-      return !node.parent || node.parent.root.role == RoleType.desktop;
-    default:
-      return false;
-  }
-};
-
-/**
  * Determines whether the two given nodes come from the same webpage.
  * @param {AutomationNode} a
  * @param {AutomationNode} b
  * @return {boolean}
  */
 AutomationUtil.isInSameWebpage = function(a, b) {
   if (!a || !b)
     return false;
 
   a = a.root;
@@ skipping 39 matching lines @@
     child = child.nextSibling;
   }
 
   if (point.x <= (loc.left + loc.width) && point.x >= loc.left &&
       point.y <= (loc.top + loc.height) && point.y >= loc.top)
     return node;
   return null;
 };
 
 });  // goog.scope