Finish implementing ChromeVox Next active indicator.

chrome/browser/resources/chromeos/chromevox/cvox2/background/output.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 Provides output services for ChromeVox.
  */
 
 goog.provide('Output');
 goog.provide('Output.EventType');
@@ skipping 45 matching lines @@
   this.speechBuffer_ = [];
   /** @type {!Array<!Spannable>} */
   this.brailleBuffer_ = [];
   /** @type {!Array<!Object>} */
   this.locations_ = [];
   /** @type {function(?)} */
   this.speechEndCallback_;
 
   /**
    * Current global options.
-   * @type {{speech: boolean, braille: boolean, location: boolean}}
+   * @type {{speech: boolean, braille: boolean}}
    */
-  this.formatOptions_ = {speech: true, braille: false, location: true};
+  this.formatOptions_ = {speech: true, braille: false};
 
   /**
    * Speech properties to apply to the entire output.
    * @type {!Object<*>}
    */
   this.speechProperties_ = {};
 };
 
 /**
  * Delimiter to use between output values.
@@ skipping 532 matching lines @@
   },
 
   /**
    * Specify ranges for speech.
    * @param {!cursors.Range} range
    * @param {cursors.Range} prevRange
    * @param {chrome.automation.EventType|Output.EventType} type
    * @return {!Output}
    */
   withSpeech: function(range, prevRange, type) {
-    this.formatOptions_ = {speech: true, braille: false, location: true};
+    this.formatOptions_ = {speech: true, braille: false};
     this.render_(range, prevRange, type, this.speechBuffer_);
     return this;
   },
 
   /**
    * Specify ranges for braille.
    * @param {!cursors.Range} range
    * @param {cursors.Range} prevRange
    * @param {chrome.automation.EventType|Output.EventType} type
    * @return {!Output}
    */
   withBraille: function(range, prevRange, type) {
-    this.formatOptions_ = {speech: false, braille: true, location: false};
+    this.formatOptions_ = {speech: false, braille: true};
     this.render_(range, prevRange, type, this.brailleBuffer_);
     return this;
   },
 
   /**
+   * Specify ranges for location.
+   * @param {!cursors.Range} range
+   * @param {cursors.Range} prevRange
+   * @param {chrome.automation.EventType|Output.EventType} type
+   * @return {!Output}
+   */
+  withLocation: function(range, prevRange, type) {
+    this.formatOptions_ = {speech: false, braille: false};
+    this.render_(range, prevRange, type, this.speechBuffer_);
+    return this;
+  },
+
+  /**
    * Specify the same ranges for speech and braille.
    * @param {!cursors.Range} range
    * @param {cursors.Range} prevRange
    * @param {chrome.automation.EventType|Output.EventType} type
    * @return {!Output}
    */
   withSpeechAndBraille: function(range, prevRange, type) {
     this.withSpeech(range, prevRange, type);
     this.withBraille(range, prevRange, type);
     return this;
   },
 
   /**
    * Applies the given speech category to the output.
    * @param {cvox.TtsCategory} category
    * @return {!Output}
    */
   withSpeechCategory: function(category) {
     this.speechProperties_['category'] = category;
     return this;
   },
 
   /**
    * Apply a format string directly to the output buffer. This lets you
    * output a message directly to the buffer using the format syntax.
    * @param {string} formatStr
    * @return {!Output}
    */
   format: function(formatStr) {
-    this.formatOptions_ = {speech: true, braille: false, location: true};
+    this.formatOptions_ = {speech: true, braille: false};
     this.format_(null, formatStr, this.speechBuffer_);
 
-    this.formatOptions_ = {speech: false, braille: true, location: false};
+    this.formatOptions_ = {speech: false, braille: true};
     this.format_(null, formatStr, this.brailleBuffer_);
 
     return this;
   },
 
   /**
    * Triggers callback for a speech event.
    * @param {function()} callback
    */
   onSpeechEnd: function(callback) {
@@ skipping 51 matching lines @@
       var output = new cvox.NavBraille({
         text: buff,
         startIndex: startIndex,
         endIndex: endIndex
       });
 
       cvox.ChromeVox.braille.write(output);
     }
 
     // Display.
-    chrome.accessibilityPrivate.setFocusRing(this.locations_);
+    if (chrome.accessibilityPrivate)

[Peter Lundblad, 2015/11/20 11:15:03]

This guard wouldn't be enoguh on Linux, where the namespace seems to be
available. When do we anticipate it wouldn't be available and do we need to
update other places where we refer to it? At least we have another call to
setFocusRing in bacgkround.sj that should be maed consistent.

[dmazzoni, 2015/11/20 23:35:14]

Agreed, testing for isChromeOS makes more sense. Done.

+      chrome.accessibilityPrivate.setFocusRing(this.locations_);
   },
 
   /**
    * Renders the given range using optional context previous range and event
    * type.
    * @param {!cursors.Range} range
    * @param {cursors.Range} prevRange
    * @param {chrome.automation.EventType|string} type
    * @param {!Array<Spannable>} buff Buffer to receive rendered output.
    * @private
@@ skipping 291 matching lines @@
   range_: function(range, prevRange, type, rangeBuff) {
     if (!prevRange)
       prevRange = cursors.Range.fromNode(range.start.node.root);
     var cursor = cursors.Cursor.fromNode(range.start.node);
     var prevNode = prevRange.start.node;
 
     var formatNodeAndAncestors = function(node, prevNode) {
       var buff = [];
       this.ancestry_(node, prevNode, type, buff);
       this.node_(node, prevNode, type, buff);
-      if (this.formatOptions_.location)
-        this.locations_.push(node.location);
+      this.locations_.push(node.location);
       return buff;
     }.bind(this);
 
     while (cursor.node != range.end.node) {
       var node = cursor.node;
       rangeBuff.push.apply(rangeBuff, formatNodeAndAncestors(node, prevNode));
       prevNode = node;
       cursor = cursor.move(cursors.Unit.NODE,
                            cursors.Movement.DIRECTIONAL,
                            Dir.FORWARD);
@@ skipping 107 matching lines @@
     var prevNode = prevRange.getBound(dir).node;
     this.ancestry_(
         range.start.node, prevNode, type, buff,
         {stay: true, name: true, value: true});
     var startIndex = range.start.index;
     var endIndex = range.end.index;
     if (startIndex === endIndex)
       endIndex++;
     this.append_(
         buff, range.start.getText().substring(startIndex, endIndex));
+    this.locations_.push(
+        range.start.node.boundsForRange(startIndex, endIndex));

[Peter Lundblad, 2015/11/20 11:15:03]

Cool, it is nice to not have to use document selection for this as I think we
had to do in classic!

[dmazzoni, 2015/11/20 23:35:14]

Acknowledged.

   },
 
   /**
    * Appends output to the |buff|.
    * @param {!Array<Spannable>} buff
    * @param {string|!Spannable} value
    * @param {{isUnique: (boolean|undefined),
    *      annotation: !Array<*>}=} opt_options
    */
   append_: function(buff, value, opt_options) {
@@ skipping 127 matching lines @@
             elem.end);
       });
       spansToRemove.forEach(result.removeSpan.bind(result));
       separator = Output.SPACE;
     });
     return result;
   }
 };
 
 });  // goog.scope