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

chrome/browser/resources/chromeos/chromevox/cvox2/background/background.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 The entry point for all ChromeVox2 related code for the
  * background page.
  */
 
 goog.provide('Background');
 goog.provide('global');
 
 goog.require('AutomationPredicate');
 goog.require('AutomationUtil');
 goog.require('cursors.Cursor');
 goog.require('cvox.TabsApiHandler');
 
 goog.scope(function() {
+var AutomationNode = chrome.automation.AutomationNode;
 var Dir = AutomationUtil.Dir;
 var EventType = chrome.automation.EventType;
-var AutomationNode = chrome.automation.AutomationNode;
 
 /** Classic Chrome accessibility API. */
 global.accessibility =
     chrome.accessibilityPrivate || chrome.experimental.accessibility;
 
 /**
  * ChromeVox2 background page.
  * @constructor
  */
 Background = function() {
   /**
    * A list of site substring patterns to use with ChromeVox next. Keep these
    * strings relatively specific.
    * @type {!Array.<string>}
    * @private
    */
   this.whitelist_ = ['http://www.chromevox.com/', 'chromevox_next_test'];
 
   /**
    * @type {cvox.TabsApiHandler}
    * @private
    */
   this.tabsHandler_ = new cvox.TabsApiHandler(cvox.ChromeVox.tts,
                                               cvox.ChromeVox.braille,
                                               cvox.ChromeVox.earcons);
 
   /**
-   * @type {chrome.automation.AutomationNode}
+   * @type {cursors.Range}
    * @private
    */
-  this.currentNode_ = null;
+  this.activeRange_ = null;

[dmazzoni, 2014/10/24 16:13:30]

Since we use "active" to mean whether ChromeVox is active at all, and since
you're using "current" as the local variable name, maybe this should be
currentRange_?

Alternate idea: virtualRange (like virtual cursor)

Or, we could rename active_ to running_?

Sorry to nitpick, but it seems like the best time to get these things right
while the ChromeVox Next codebase is small. It will make it so much more
readable in the future.

 
   /**
    * Whether ChromeVox Next is active.
    * @type {boolean}
    * @private
    */
   this.active_ = false;
 
   // Only needed with unmerged ChromeVox classic loaded before.
   global.accessibility.setAccessibilityEnabled(false);
@@ skipping 59 matching lines @@
   /**
    * Handles chrome.commands.onCommand.
    * @param {string} command
    */
   onGotCommand: function(command) {
     if (command == 'toggleChromeVoxVersion') {
       this.toggleChromeVoxVersion();
       return;
     }
 
-    if (!this.active_ || !this.current_)
+    if (!this.active_ || !this.activeRange_)
       return;
 
-    var previous = this.current_;
-    var current = this.current_;
-
+    var current = this.activeRange_;
     var dir = Dir.FORWARD;
     var pred = null;
     switch (command) {
       case 'nextHeading':
         dir = Dir.FORWARD;
         pred = AutomationPredicate.heading;
         break;
       case 'previousHeading':
         dir = Dir.BACKWARD;
         pred = AutomationPredicate.heading;
         break;
       case 'nextLine':
-        dir = Dir.FORWARD;
-        pred = AutomationPredicate.inlineTextBox;
+        current = current.move(cursors.Unit.LINE, Dir.FORWARD);
         break;
       case 'previousLine':
-        dir = Dir.BACKWARD;
-        pred = AutomationPredicate.inlineTextBox;
+        current = current.move(cursors.Unit.LINE, Dir.BACKWARD);
         break;
       case 'nextLink':
         dir = Dir.FORWARD;
         pred = AutomationPredicate.link;
         break;
       case 'previousLink':
         dir = Dir.BACKWARD;
         pred = AutomationPredicate.link;
         break;
       case 'nextElement':
-        current = current.role == chrome.automation.RoleType.inlineTextBox ?
-            current.parent() : current;
-        current = AutomationUtil.findNextNode(current,
-            Dir.FORWARD,
-            AutomationPredicate.inlineTextBox);
-        current = current ? current.parent() : current;
+        current = current.move(cursors.Unit.NODE, Dir.FORWARD);
         break;
       case 'previousElement':
-        current = current.role == chrome.automation.RoleType.inlineTextBox ?
-            current.parent() : current;
-        current = AutomationUtil.findNextNode(current,
-            Dir.BACKWARD,
-            AutomationPredicate.inlineTextBox);
-        current = current ? current.parent() : current;
+        current = current.move(cursors.Unit.NODE, Dir.BACKWARD);
         break;
       case 'goToBeginning':
-        current = AutomationUtil.findNodePost(current.root,
+      var node = AutomationUtil.findNodePost(current.getStart().getNode().root,
             Dir.FORWARD,
-            AutomationPredicate.inlineTextBox);
+            AutomationPredicate.leaf);
+      if (node)
+        current = cursors.Range.fromNode(node);
         break;
       case 'goToEnd':
-        current = AutomationUtil.findNodePost(current.root,
+      var node =
+          AutomationUtil.findNodePost(current.getStart().getNode().root,
             Dir.BACKWARD,
-            AutomationPredicate.inlineTextBox);
+            AutomationPredicate.leaf);
+      if (node)
+        current = cursors.Range.fromNode(node);
         break;
     }
 
-    if (pred)
-      current = AutomationUtil.findNextNode(current, dir, pred);
+    if (pred) {
+      var node = AutomationUtil.findNextNode(
+          current.getBound(dir).getNode(), dir, pred);
+
+      if (node)
+        current = cursors.Range.fromNode(node);
+    }
 
     if (current) {
-      current.focus();
+      current.getStart().getNode().focus();

[dmazzoni, 2014/10/24 16:13:29]

Perhaps this should call a method on current that says to focus any focusable
elements contained within the range? For example, if the active range is a
single line containing a link, we should focus the link even though it's not the
start node.

OK to just mark as TODO, or write the helper function but not fully implement it
yet.

 
-      this.onFocus({target: current});
+      this.activeRange_ = current;
+      this.handleOutput(this.activeRange_);
     }
   },
 
   /**
    * Provides all feedback once ChromeVox's focus changes.
    * @param {Object} evt
    */
   onFocus: function(evt) {
     var node = evt.target;
     if (!node)
       return;
 
-    this.current_ = node;
-    var container = node;
-    while (container &&
-        (container.role == chrome.automation.RoleType.inlineTextBox ||
-        container.role == chrome.automation.RoleType.staticText))
-      container = container.parent();
-
-    var role = container ? container.role : node.role;
-
-    var output =
-        [node.attributes.name, node.attributes.value, role].join(', ');
-    cvox.ChromeVox.tts.speak(output, cvox.QueueMode.FLUSH);
-    cvox.ChromeVox.braille.write(cvox.NavBraille.fromText(output));
-    chrome.accessibilityPrivate.setFocusRing([evt.target.location]);
+    this.activeRange_ = cursors.Range.fromNode(node);
+    this.handleOutput(this.activeRange_);
   },
 
   /**
    * Provides all feedback once a load complete event fires.
    * @param {Object} evt
    */
   onLoadComplete: function(evt) {
-    if (this.current_)
+    if (this.activeRange_)
       return;
 
-    this.current_ = AutomationUtil.findNodePost(evt.target,
+    var node = AutomationUtil.findNodePost(evt.target,
         Dir.FORWARD,
-        AutomationPredicate.inlineTextBox);
-    this.onFocus({target: this.current_});
+        AutomationPredicate.leaf);
+    if (node)
+      this.activeRange_ = cursors.Range.fromNode(node);
+
+    if (this.activeRange_)
+      this.handleOutput(this.activeRange_);
   },
 
   /**
    * @private
    * @param {string} url
    * @return {boolean} Whether the given |url| is whitelisted.
    */
   isWhitelisted_: function(url) {
     return this.whitelist_.some(function(item) {
       return url.indexOf(item) != -1;
@@ skipping 21 matching lines @@
       opt_options.next = !this.active_;
       opt_options.classic = !opt_options.next;
     }
 
     if (opt_options.next) {
       chrome.automation.getTree(this.onGotTree);
       this.active_ = true;
     } else {
       if (this.active_) {
         for (var eventType in this.listeners_) {
-          this.current_.root.removeEventListener(
+          this.activeRange_.getStart().getNode().root.removeEventListener(
               eventType, this.listeners_[eventType], true);
         }
       }
       this.active_ = false;
     }
 
     chrome.tabs.query({active: true}, function(tabs) {
       if (opt_options.classic) {
         cvox.ChromeVox.injectChromeVoxIntoTabs(tabs);
       } else {
         tabs.forEach(function(tab) {
           this.disableClassicChromeVox_(tab.id);
         }.bind(this));
       }
     }.bind(this));
+  },
+
+  /**
+   * Handles output of a Range.
+   * @param {!cursors.Range} range Current location.
+   */
+  handleOutput: function(range) {
+    // TODO(dtseng): This is just placeholder logic for generating descriptions
+    // pending further design discussion.
+    function getCursorDesc(cursor) {
+      var node = cursor.getNode();
+      var container = node;
+      while (container &&
+          (container.role == chrome.automation.RoleType.inlineTextBox ||
+          container.role == chrome.automation.RoleType.staticText))
+        container = container.parent();
+
+      var role = container ? container.role : node.role;
+      return [node.attributes.name, node.attributes.value, role].join(', ');
+    }
+
+    // Walk the range and collect descriptions.
+    var output = '';
+    var cursor = range.getStart();
+    var nodeLocations = [];
+    while (cursor.getNode() != range.getEnd().getNode()) {
+      output += getCursorDesc(cursor);
+      nodeLocations.push(cursor.getNode().location);
+      cursor = cursor.move(
+          cursors.Unit.NODE, cursors.Movement.DIRECTIONAL, Dir.FORWARD);
+    }
+    output += getCursorDesc(range.getEnd());
+    nodeLocations.push(range.getEnd().getNode().location);
+
+    cvox.ChromeVox.tts.speak(output, cvox.QueueMode.FLUSH);
+    cvox.ChromeVox.braille.write(cvox.NavBraille.fromText(output));
+    chrome.accessibilityPrivate.setFocusRing(nodeLocations);
   }
 };
 
 /** @type {Background} */
 global.backgroundObj = new Background();
 
 });  // goog.scope