Implement ChromeVox next/previous line, link, and heading.

chrome/browser/resources/chromeos/chromevox2/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('cvox2.Background');
 goog.provide('cvox2.global');
 
 /** Classic Chrome accessibility API. */
 cvox2.global.accessibility =
     chrome.accessibilityPrivate || chrome.experimental.accessibility;
 
 /**
  * ChromeVox2 background page.
  */
 cvox2.Background = function() {
   /**
    * A list of site substring patterns to use with ChromeVox next. Keep these
    * strings relatively specific.
    * @type {!Array.<string>}
    */
   this.whitelist_ = ['http://www.chromevox.com/', 'chromevox_next_test'];
 
+  /** @type {AutomationElement} @private */
+  this.currentElement_ = null;
+
   // Only needed with unmerged ChromeVox classic loaded before.
   // TODO(dtseng): Refactor all tabs handlers out of
   // accessibility_api_handler.js.
   cvox2.global.accessibility.setAccessibilityEnabled(false);
 
   // Manually bind all functions to |this|.
   for (var func in this) {
     if (typeof(this[func]) == 'function')
       this[func] = this[func].bind(this);
   }
@@ skipping 41 matching lines @@
     root.addEventListener(chrome.automation.EventType.focus,
                           this.onAutomationEvent.bind(this),
                           true);
   },
 
   /**
    * A generic handler for all desktop automation events.
    * @param {AutomationEvent} evt The event.
    */
   onAutomationEvent: function(evt) {
-    var output = evt.target.attributes.name + ' ' + evt.target.role;
-    cvox.ChromeVox.tts.speak(output, cvox.AbstractTts.QUEUE_MODE_FLUSH);
-    cvox.ChromeVox.braille.write(cvox.NavBraille.fromText(output));
+    switch (evt.type) {
+      case 'focus':
+        this.onFocus(evt.target);
+    }
   },
 
   /**
    * Handles chrome.commands.onCommand.
    * @param {string} command
    */
   onGotCommand: function(command) {
+    if (!this.current_)
+      return;
+
+    function find(cur, r, pred) {
+      if (pred(cur))
+        return cur;
+      var child = r ? cur.lastChild() : cur.firstChild();
+      while (child) {
+        var ret = find(child, r, pred);
+        if (ret)
+        return ret;

[dmazzoni, 2014/09/22 06:44:26]

nit: indent

[David Tseng, 2014/09/22 23:45:34]

Done.

+        child = r ? child.previousSibling() : child.nextSibling();
+      }
+    }
+
+    function findNextSubtree(cur, r) {
+      while (cur) {
+        var next = r ? cur.previousSibling() : cur.nextSibling();
+        if (next)
+          return next;
+
+        cur = cur.parent();
+      }
+    }
+
+    function moveNext(cur, r, pred) {
+      var next = cur;
+      do {
+        if (!(next = findNextSubtree(cur, r)))
+          return null;
+        cur = next;
+        next = find(next, r, pred);
+      } while (!next);
+      return next;
+    }
+
+    var previous = this.current_;
+    var current = this.current_;
+    switch (command) {
+      case 'nextHeading':
+        current = moveNext(current, false, function(e) {
+          return e.role == 'heading';
+        });
+        break;
+      case 'previousHeading':
+        current = moveNext(current, true, function(e) {

[Peter Lundblad, 2014/09/22 09:30:59]

I think using predicates like this is nice.  I suggest creating a separate
utility namespace with those to make the code less verbose and more
maintainable.

[David Tseng, 2014/09/22 23:45:34]

Done.

+          return e.role == 'heading';
+        });
+        break;
+      case 'nextLine':
+        current = moveNext(current, false, function(e) {
+          return e.role == 'inlineTextBox';

[dmazzoni, 2014/09/22 06:44:26]

FWIW, since inline text boxes aren't actually nodes, I was thinking maybe they
should be abstracted from ChromeVox by the automation API. ChromeVox would just
see static text nodes, but there'd be methods to get line info.

Note that there are sometimes multiple inline text boxes per line

[David Tseng, 2014/09/22 23:41:29]

I actually think leaving them in the tree will simplify ChromeVox code. If the
following are true, then we can base all navigation off of in-line text boxes.
- they exist as children even if a parent has no text.
- their immediate parent's role should be announced (e.g. link, heading,
listitem).

So, the rules we use would be as follows:
line navigation: simply move to the next/previous in-line textbox in depth-first
order.
go to beginning: sync (drill down) into the deepest in-line textbox.
go to end: sync (drill down) into the deepest in-line textbox (reversed/moving
right to left).
element/item navigation: move to the parent of the current in-line textbox; now,
move to the next/previous in-line textbox. Finally, return the parent.
group navigation: based upon element navigation; perhaps based on specific
roles.

on each navigation, these "nodes" could be treated in the same way in terms of
highlighting rectangles.

+        });
+        break;
+      case 'previousLine':
+        current = moveNext(current, true, function(e) {
+          return e.role == 'inlineTextBox';
+        });
+        break;
+      case 'nextLink':
+        current = moveNext(current, false, function(e) {
+          return e.role == 'link';
+        });
+        break;
+      case 'previousLink':
+        current = moveNext(current, true, function(e) {
+          return e.role == 'link';
+        });
+        break;
+    }
+    if (current)
+      current.focus();
+    this.onFocus(current || previous);
   },
 
   /**
+   * Provides all feedback once ChromeVox's focus changes.
+   * @param {AutomationElement} element The newly focused element.
+   */
+  onFocus: function(element) {
+    var container = element;
+    while (container && (container.role == 'inlineTextBox' ||
+        container.role == 'staticText'))
+      container = container.parent();
+
+    var role = container ? container.role : element.role;
+
+    var output =
+        [element.attributes.name, element.attributes.value, role].join(',');
+    cvox.ChromeVox.tts.speak(output, cvox.AbstractTts.QUEUE_MODE_FLUSH);
+    cvox.ChromeVox.braille.write(cvox.NavBraille.fromText(output));
+    this.current_ = element;
+  },
+
+  /**
    * @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;
     }.bind(this));
   },
 
   /**
    * Disables classic ChromeVox.
    * @param {number} tabId The tab where ChromeVox classic is running.
    */
   disableClassicChromeVox_: function(tabId) {
     chrome.tabs.executeScript(
           tabId,
           {'code': 'try { window.disableChromeVox(); } catch(e) { }\n',
            'allFrames': true});
   }
 };
 
 /** @type {cvox2.Background} */
 cvox2.global.backgroundObj = new cvox2.Background();