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.range_ = null;

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

Does this mean the current selected object? Maybe currentRange_ or activeRange_?

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

Either make the name more self-explanatory or add a description in the jsdoc.

 
   /**
    * 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.range_)
       return;
 
-    var previous = this.current_;
-    var current = this.current_;
-
+    var current = this.range_.clone();
     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.move(cursors.Unit.LINE, Dir.FORWARD);
         break;
       case 'previousLine':
-        dir = Dir.BACKWARD;
-        pred = AutomationPredicate.inlineTextBox;
+        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.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.move(cursors.Unit.NODE, Dir.BACKWARD);
         break;
       case 'goToBeginning':
-        current = AutomationUtil.findNodePost(current.root,
+        var node = AutomationUtil.findNodePost(current.start.node.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.start.node.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.collapse(dir).start.node, dir, pred);
+
+      if (node)
+        current = cursors.Range.fromNode(node);
+    }
 
     if (current) {
-      current.focus();
+      current.start.node.focus();
 
-      this.onFocus({target: current});
+      this.range_ = current;
+      this.handleOutput(this.range_);
     }
   },
 
   /**
    * 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.range_ = cursors.Range.fromNode(node);
+    this.handleOutput(this.range_);
   },
 
   /**
    * Provides all feedback once a load complete event fires.
    * @param {Object} evt
    */
   onLoadComplete: function(evt) {
-    if (this.current_)
+    if (this.range_)
       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.range_ = cursors.Range.fromNode(node);
+
+    if (this.range_)
+      this.handleOutput(this.range_);
   },
 
   /**
    * @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.range_.start.node.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.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;
+
+      return [node.attributes.name, node.attributes.value, role].join(', ');
+    }
+
+    // Walk the range and collect descriptions.
+    var output = '';
+    var cursor = range.start.clone();
+    var nodeLocations = [];
+    while (cursor.node != range.end.node) {
+      output += getCursorDesc(cursor);
+      nodeLocations.push(cursor.node.location);
+      cursor.move(cursors.Unit.NODE, cursors.Movement.DIRECTIONAL, Dir.FORWARD);
+    }
+    output += getCursorDesc(range.end);
+    nodeLocations.push(range.end.node.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