Add support for rich output inside of content editables.

chrome/browser/resources/chromeos/chromevox/cvox2/background/editing.js

 // Copyright 2015 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 Processes events related to editing text and emits the
  * appropriate spoken and braille feedback.
  */
 
 goog.provide('editing.TextEditHandler');
 
 goog.require('AutomationTreeWalker');
 goog.require('AutomationUtil');
 goog.require('Output');
 goog.require('Output.EventType');
 goog.require('cursors.Cursor');
 goog.require('cursors.Range');
 goog.require('cvox.ChromeVoxEditableTextBase');
 
 goog.scope(function() {
 var AutomationEvent = chrome.automation.AutomationEvent;
 var AutomationNode = chrome.automation.AutomationNode;
 var Cursor = cursors.Cursor;
-var Dir = AutomationUtil.Dir;
+var Dir = constants.Dir;
 var EventType = chrome.automation.EventType;
 var Range = cursors.Range;
 var RoleType = chrome.automation.RoleType;
 var Movement = cursors.Movement;
 var Unit = cursors.Unit;
 
 /**
  * A handler for automation events in a focused text field or editable root
  * such as a |contenteditable| subtree.
  * @constructor
@@ skipping 99 matching lines @@
     if (!this.multiline)
       return 0;
     var breaks = this.node_.lineBreaks || [];
     var index = 0;
     while (index < breaks.length && breaks[index] <= charIndex)
       ++index;
     return index;
   },
 
   /** @override */
+  describeLine: function(lineIndex, triggeredByUser) {
+    if (!this.node_.state.richlyEditable) {
+      cvox.ChromeVoxEditableTextBase.prototype.describeLine.call(
+          this, lineIndex, triggeredByUser);
+      return;
+    }
+    var line = this.getSelectedAutomationLine_();
+    if (line) {
+      new Output().withRichSpeech(line, null, Output.EventType.NAVIGATE)
+          .go();
+    }
+  },
+
+  /** @override */
   getLineStart: function(lineIndex) {
     if (!this.multiline || lineIndex == 0)
       return 0;
     var breaks = this.getLineBreaks_();
     return breaks[lineIndex - 1] || this.node_.value.length;
   },
 
   /** @override */
   getLineEnd: function(lineIndex) {
     var breaks = this.getLineBreaks_();
@@ skipping 12 matching lines @@
    * @private
    */
   getLineBreaks_: function() {
     // node.lineBreaks is undefined when the multiline field has no line
     // breaks.
     return this.node_.lineBreaks || [];
   },
 
   /** @private */
   outputBraille_: function() {
-    var isFirstLine = false;  // First line in a multiline field.
+    // First line in a multiline field.
+    var lineIndex = this.getLineIndex(this.start);
+    var isFirstLine = this.multiline && lineIndex == 0;
     var output = new Output();
     var range;
-    if (this.multiline) {
-      var lineIndex = this.getLineIndex(this.start);
-      if (lineIndex == 0) {
-        isFirstLine = true;
+    if (this.node_.state.richlyEditable) {
+      range = this.getSelectedAutomationLine_();
+    } else if (this.multiline) {
+      if (isFirstLine)
         output.formatForBraille('$name', this.node_);
-      }
       range = new Range(
           new Cursor(this.node_, this.getLineStart(lineIndex)),
           new Cursor(this.node_, this.getLineEnd(lineIndex)));
     } else {
       range = Range.fromNode(this.node_);
     }
-    output.withBraille(range, null, Output.EventType.NAVIGATE);
+    if (range)
+      output.withBraille(range, null, Output.EventType.NAVIGATE);
     if (isFirstLine)
       output.formatForBraille('@tag_textarea');
     output.go();
+  },
+
+  /**
+   * @return {Range}
+   * @private
+   */
+  getSelectedAutomationLine_: function() {
+    if (!this.node_.root.anchorObject || !this.node_.root.focusObject)
+      return null;
+
+    var start = Cursor.fromNode(this.node_.root.anchorObject);
+    start = start.move(Unit.LINE, Movement.BOUND, Dir.BACKWARD);
+    var end = Cursor.fromNode(this.node_.root.focusObject);
+    end = end.move(Unit.LINE, Movement.BOUND, Dir.FORWARD);
+    return new Range(start, end);
   }
 };
 
 /**
  * @param {!AutomationNode} node The root editable node, i.e. the root of a
  *     contenteditable subtree or a text field.
  * @return {editing.TextEditHandler}
  */
 editing.TextEditHandler.createForNode = function(node) {
   var rootFocusedEditable = null;
   var testNode = node;
 
   do {
     if (testNode.state.focused && testNode.state.editable)
       rootFocusedEditable = testNode;
     testNode = testNode.parent;
   } while (testNode);
 
   if (rootFocusedEditable)
     return new TextFieldTextEditHandler(rootFocusedEditable);
 
   return null;
 };
 
 });