Implemented scanning by group

chrome/browser/resources/chromeos/switch_access/automation_manager.js

 // Copyright 2017 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.
 
 /**
  * Class to manage interactions with the accessibility tree, including moving
  * to and selecting nodes.
  *
  * @constructor
  */
 function AutomationManager() {
   /**
-   * Currently selected node.
+   * Currently highlighted node.
    *
    * @private {chrome.automation.AutomationNode}
    */
   this.node_ = null;
 
   /**
-   * Root node (i.e., the desktop).
+   * The root of the subtree that the user is navigating through.
    *
    * @private {chrome.automation.AutomationNode}
    */
-  this.root_ = null;
+  this.scope_ = null;
+
+  /**
+   * The desktop node.
+   *
+   * @private {chrome.automation.AutomationNode}
+   */
+  this.desktop_ = null;
+
+  /**
+   * A list of past subtree roots. Allows user to traverse back to previous

[dmazzoni, 2017/05/05 18:23:19]

Would it be more clear to say this is a list of past
scopes?

Also, document whether the most recent is at the beginning
or end of the list.

Is this a stack? Maybe you could call it scopeStack so that
it's more intuitive that you add and pop stacks from the end
of the list.

[elichtenberg, 2017/05/06 00:13:53]

Done.

+   * groups after selecting one or more groups.
+   *
+   * @private {Array<chrome.automation.AutomationNode>}
+   */
+  this.oldScopes_ = [];
 
   /**
    * Moves to the appropriate node in the accessibility tree.
    *
    * @private {AutomationTreeWalker}
    */
   this.treeWalker_ = null;
 
   this.init_();
 };
 
 AutomationManager.prototype = {
   /**
-   * Set this.node_ and this.root_ to the desktop node, and initialize the
-   * tree walker.
+   * Set this.node_, this.root_, and this.desktop_ to the desktop node, and
+   * creates an initial tree walker.
    *
    * @private
    */
   init_: function() {
-    this.treeWalker_ = new AutomationTreeWalker();
-
     chrome.automation.getDesktop(function(desktop) {
       this.node_ = desktop;
-      this.root_ = desktop;
+      this.scope_ = desktop;
+      this.desktop_ = desktop;
+      this.treeWalker_ = this.createTreeWalker_(desktop);
       console.log('AutomationNode for desktop is loaded');
       this.printNode_(this.node_);
     }.bind(this));
   },
 
   /**
    * Set this.node_ to the next/previous interesting node, and then highlight
    * it on the screen. If no interesting node is found, set this.node_ to the
    * first/last interesting node. If |doNext| is true, will search for next
    * node. Otherwise, will search for previous node.
    *
    * @param {boolean} doNext
    */
   moveToNode: function(doNext) {
-    let node = this.treeWalker_.moveToNode(this.node_, this.root_, doNext);
+    if (!this.treeWalker_)
+      return;
+
+    let node = this.treeWalker_.moveToNode(doNext);
     if (node) {
       this.node_ = node;
       this.printNode_(this.node_);
       chrome.accessibilityPrivate.setFocusRing([this.node_.location]);
     }
   },
 
   /**
-   * Perform the default action on the currently selected node.
+   * Select the currently highlighted node. If the node is a group, create a

[dmazzoni, 2017/05/05 18:23:19]

Also document what happens if you're on the current scope.

[elichtenberg, 2017/05/06 00:13:53]

Done.

+   * new tree walker for the new subtree the user is scanning through.
+   * Otherwise, meaning the node is interesting, perform the default action on
+   * it.
    */
-  doDefault: function() {
-    if (!this.node_)
+  selectCurrentNode: function() {
+    if (!this.node_ || !this.scope_ || !this.treeWalker_)
       return;
 
+    if (this.node_ === this.scope_) {
+      let oldScope = this.oldScopes_.pop();
+
+      // Don't let user select the top-level root node (i.e., the desktop node).
+      if (!oldScope)

[dmazzoni, 2017/05/05 18:25:52]

One possible bug - it's possible that the old scope is no
longer valid.

For example, imagine someone navigates to the close box for
a window or dialog and clicks on it. The previous scope may
have been the window itself, which no longer exists. You should
keep walking up until you find a valid scope.

An invalid node will still be a valid JavaScript object, but
all of its attributes like role and state will return undefined.

[elichtenberg, 2017/05/06 00:13:53]

Done.

+        return;
+
+      this.scope_ = oldScope;
+      this.treeWalker_ = this.createTreeWalker_(this.scope_, this.node_);
+      return;
+    }
+
+    if (AutomationPredicate.isGroup(this.node_, this.scope_)) {
+      this.oldScopes_.push(this.scope_);
+      this.scope_ = this.node_;
+      this.treeWalker_ = this.createTreeWalker_(this.scope_);
+      return;
+    }
+
     this.node_.doDefault();
   },
 
+  /**
+   * Create an AutomationTreeWalker for the subtree with |scope| as its root.
+   * If |opt_start| is defined, the tree walker will start walking the tree
+   * from |opt_start|; otherwise, it will start from |scope|.
+   *
+   * @param {!chrome.automation.AutomationNode} scope
+   * @param {!chrome.automation.AutomationNode=} opt_start
+   * @return {!AutomationTreeWalker}
+   */
+  createTreeWalker_: function(scope, opt_start) {
+    // If no explicit start node, start walking the tree from |scope|.

[dmazzoni, 2017/05/05 18:23:19]

Does it start at |scope|, or at the first child?

Intuitively when you click on a group, shouldn't it jump
to the first child within the group?

[elichtenberg, 2017/05/06 00:13:53]

I agree. I changed selectCurrentNode so that when you select a group, you
automatically move to the next node. I didn't want to change createTreeWalker
though since we won't always want to move to the next node (e.g., when you
select the current scope).

+    let start = opt_start || scope;
+
+    let leafPred = function(node) {
+      return (node !== scope && AutomationPredicate.isSubtreeLeaf(node, scope))
+          || !AutomationPredicate.isInterestingSubtree(node);
+    };
+    let visitPred = function(node) {
+      // Avoid visiting the top-level root node (i.e., the desktop node).
+      return node !== this.desktop_
+          && AutomationPredicate.isSubtreeLeaf(node, scope);
+    }.bind(this);
+
+    let restrictions = {
+      leaf: leafPred,
+      visit: visitPred
+    };
+    return new AutomationTreeWalker(start, scope, restrictions);
+  },
+
   // TODO(elichtenberg): Move print functions to a custom logger class. Only
   // log when debuggingEnabled is true.
   /**
    * Print out details about a node.
    *
    * @param {chrome.automation.AutomationNode} node
    * @private
    */
   printNode_: function(node) {
     if (node) {
@@ skipping 57 matching lines @@
    */
   debugMoveToParent: function() {
     let parent = this.treeWalker_.debugMoveToParent(this.node_);
     if (parent) {
       this.node_ = parent;
       this.printNode_(this.node_);
       chrome.accessibilityPrivate.setFocusRing([this.node_.location]);
     }
   }
 };