add support for rich text selections

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');
@@ skipping 209 matching lines @@
  * @param {!AutomationNode} node
  * @extends {AutomationEditableText}
  */
 function AutomationRichEditableText(node) {
   AutomationEditableText.call(this, node);
 
   var root = this.node_.root;
   if (!root || !root.anchorObject || !root.focusObject)
     return;
 
-  this.line_ = new editing.EditableLine(
-      root.anchorObject, root.anchorOffset, root.focusObject, root.focusOffset);
+  this.anchorLine_ = new editing.EditableLine(root.anchorObject,

[dmazzoni, 2017/06/19 15:11:51]

Is the plan to refactor EditableLine to only take two arguments now?

[David Tseng, 2017/06/19 18:27:47]

No, added comments to clarify. An editable line contains both the selection
state and the line state. For things larger than a line, we want to truncate the
selection at bounds. We're saving anchor and focus line to get the selection
edges to do state comparisons (as to avoi generating all lines in the
selection).

+                                              root.anchorOffset,
+                                              root.anchorObject,
+                                              root.anchorOffset);
+  this.focusLine_ = new editing.EditableLine(root.focusObject,
+                                              root.focusOffset,
+                                              root.focusObject,
+                                              root.focusOffset);
 }
 
 AutomationRichEditableText.prototype = {
   __proto__: AutomationEditableText.prototype,
 
   /** @override */
   onUpdate: function() {
     var root = this.node_.root;
     if (!root.anchorObject || !root.focusObject)
       return;
 
+    var anchorLine = new editing.EditableLine(root.anchorObject,
+                                              root.anchorOffset,
+                                              root.anchorObject,
+                                              root.anchorOffset);
+    var focusLine = new editing.EditableLine(root.focusObject,
+                                             root.focusOffset,
+                                             root.focusObject,
+                                             root.focusOffset);
+
+    var prevAnchorLine = this.anchorLine_;
+    var prevFocusLine = this.focusLine_;
+    this.anchorLine_ = anchorLine;
+    this.focusLine_ = focusLine;
+
+    // Compute the current line based upon whether the current selection was
+    // extended from anchor or focus. The default behavior is to compute lines
+    // via focus.
+    var baseLineOnStart = prevFocusLine.strictEquals(focusLine);
+
     var cur = new editing.EditableLine(
         root.anchorObject, root.anchorOffset || 0,
-        root.focusObject, root.focusOffset || 0);
-    var prev = this.line_;
+        root.focusObject, root.focusOffset || 0,
+        baseLineOnStart);
     this.line_ = cur;
 
-    if (prev.equals(cur)) {
-      // Collapsed cursor.
+    // Selection stayed within the same line(s) and didn't cross into new lines.
+    if (anchorLine.equals(prevAnchorLine) && focusLine.equals(prevFocusLine)) {
+      // Intra-line changes.
       this.changed(new cvox.TextChangeEvent(
           cur.text || '',
           cur.startOffset || 0,
           cur.endOffset || 0,
           true));
       this.brailleCurrentRichLine_();
 
       // Finally, queue up any text markers/styles at bounds.
       var container = cur.startContainer_;
       if (!container)
@@ skipping 27 matching lines @@
 
       // Start of the container.
       if (cur.containerStartOffset == cur.startOffset)
         this.speakTextStyle_(container);
       else if (cur.containerEndOffset == cur.endOffset)
         this.speakTextStyle_(container, true);
 
       return;
     }
 
-    // Just output the current line.
-    cvox.ChromeVox.tts.speak(cur.text, cvox.QueueMode.CATEGORY_FLUSH);
-    this.brailleCurrentRichLine_();
+    if (anchorLine.equals(focusLine)) {
+      // Current selection is on a new line not part of the previous selection.
+      this.line_ = focusLine;
+      cvox.ChromeVox.tts.speak(focusLine.text, cvox.QueueMode.CATEGORY_FLUSH);
+      this.brailleCurrentRichLine_();
+    } if (prevAnchorLine.equals(anchorLine)) {
+      // The selection changed in focus position.
+      this.line_ = focusLine;
+      cvox.ChromeVox.tts.speak(focusLine.text, cvox.QueueMode.CATEGORY_FLUSH);
+      this.brailleCurrentRichLine_();
+    } else if (prevFocusLine.equals(focusLine)) {
+      // The selection changed in anchor position.
+      this.line_ = anchorLine;
+      cvox.ChromeVox.tts.speak(anchorLine.text, cvox.QueueMode.CATEGORY_FLUSH);
+      this.brailleCurrentRichLine_();
+    } else {
+      // Describe a generic DOM selection.

[dmazzoni, 2017/06/19 15:11:51]

Want to put some sort of placeholder here?

Or maybe just favor the change to the focus?

[David Tseng, 2017/06/19 18:27:47]

Removed. We don't want to favor focus but favor the line edge of the selection
that changed which is actually |cur|. I added more comments and tests to try to
clarify.

+    }
 
     // The state in EditableTextBase needs to get updated with the new line
     // contents, so that subsequent intra-line changes get the right state
     // transitions.
     this.value = cur.text;
     this.start = cur.startOffset;
     this.end = cur.endOffset;
   },
 
   /**
@@ skipping 137 matching lines @@
 };
 
 /**
  * @private {ChromeVoxStateObserver}
  */
 editing.observer_ = new editing.EditingChromeVoxStateObserver();
 
 /**
  * An EditableLine encapsulates all data concerning a line in the automation
  * tree necessary to provide output.
+ * @param {AutomationNode} startNode
+ * @param {number} startIndex
+ * @param {AutomationNode} endNode
+ * @param {number} endIndex
+ * @param {boolean=} opt_baseLineOnStart
  * @constructor
   */
-editing.EditableLine = function(startNode, startIndex, endNode, endIndex) {
+editing.EditableLine =
+    function(startNode, startIndex, endNode, endIndex, opt_baseLineOnStart) {
   /** @private {!Cursor} */
   this.start_ = new Cursor(startNode, startIndex);
   this.start_ = this.start_.deepEquivalent || this.start_;
 
   /** @private {!Cursor} */
   this.end_ = new Cursor(endNode, endIndex);
   this.end_ = this.end_.deepEquivalent || this.end_;
   /** @private {number} */
   this.localContainerStartOffset_ = startIndex;
 
   // Computed members.
   /** @private {Spannable} */
   this.value_;
   /** @private {AutomationNode} */
   this.lineStart_;
   /** @private {AutomationNode} */
   this.lineEnd_;
   /** @private {AutomationNode|undefined} */
   this.startContainer_;
   /** @private {AutomationNode|undefined} */
   this.lineStartContainer_;
   /** @private {number} */
   this.localLineStartContainerOffset_ = 0;
+  /** @private {AutomationNode|undefined} */
+  this.lineEndContainer_;
+  /** @private {number} */
+  this.localLineEndContainerOffset_ = 0;
 
-  this.computeLineData_();
+  this.computeLineData_(opt_baseLineOnStart);
 };
 
 editing.EditableLine.prototype = {
   /** @private */
-  computeLineData_: function() {
+  computeLineData_: function(opt_baseLineOnStart) {
+    // Note that we calculate the line based only upon anchor or focus even if
+    // they do not fall on the same line. It is up to the caller to specify
+    // which end to base this line upon since it requires reasoning about two
+    // lines.
     var nameLen = 0;
-    if (this.start_.node.name)
-      nameLen = this.start_.node.name.length;
+    var lineBase = opt_baseLineOnStart ? this.start_ : this.end_;
+    var lineExtend = opt_baseLineOnStart ? this.end_ : this.start_;
 
-    this.value_ = new Spannable(this.start_.node.name || '', this.start_);
-    if (this.start_.node == this.end_.node)
-      this.value_.setSpan(this.end_, 0, nameLen);
+    if (lineBase.node.name)
+      nameLen = lineBase.node.name.length;
+
+    this.value_ = new Spannable(lineBase.node.name || '', lineBase);
+    if (lineBase.node == lineExtend.node)
+      this.value_.setSpan(lineExtend, 0, nameLen);
 
     // Initialize defaults.
-    this.lineStart_ = this.start_.node;
+    this.lineStart_ = lineBase.node;
     this.lineEnd_ = this.lineStart_;
     this.startContainer_ = this.lineStart_.parent;
     this.lineStartContainer_ = this.lineStart_.parent;
+    this.lineEndContainer_ = this.lineStart_.parent;
 
     // Annotate each chunk with its associated inline text box node.
     this.value_.setSpan(this.lineStart_, 0, this.lineStart_.name.length);
 
     // If the current selection is not on an inline text box (e.g. an image),
     // return early here so that the line contents are just the node. This is
     // pending the ability to show non-text leaf inline objects.
     if (this.lineStart_.role != RoleType.INLINE_TEXT_BOX)
       return;
 
@@ skipping 26 matching lines @@
       this.lineEnd_ = lineEnd;
       if (parents[parents.length - 1] != lineEnd.parent)
         parents.push(this.lineEnd_.parent);
 
       var annotation = lineEnd;
       if (lineEnd == this.end_.node)
         annotation = this.end_;
 
       this.value_.append(new Spannable(lineEnd.name, annotation));
     }
+    this.lineEndContainer_ = this.lineEnd_.parent;
 
     // Finally, annotate with all parent static texts as NodeSpan's so that
     // braille routing can key properly into the node with an offset.
     // Note that both line start and end needs to account for
     // potential offsets into the static texts as follows.
     var textCountBeforeLineStart = 0, textCountAfterLineEnd = 0;
     var finder = this.lineStart_;
     while (finder.previousSibling) {
       finder = finder.previousSibling;
       textCountBeforeLineStart += finder.name.length;
     }
     this.localLineStartContainerOffset_ = textCountBeforeLineStart;
 
     finder = this.lineEnd_;
     while (finder.nextSibling) {
       finder = finder.nextSibling;
       textCountAfterLineEnd += finder.name.length;
     }
 
+    if (this.lineEndContainer_.name) {
+      this.localLineEndContainerOffset_ =
+          this.lineEndContainer_.name.length - textCountAfterLineEnd;
+    }
+
     var len = 0;
     for (var i = 0; i < parents.length; i++) {
       var parent = parents[i];
 
       if (!parent.name)
         continue;
 
       var prevLen = len;
 
       var currentLen = parent.name.length;
@@ skipping 19 matching lines @@
           this.value_.setSpan(parent, prevLen, len);
       } catch (e) {}
     }
   },
 
   /**
    * Gets the selection offset based on the text content of this line.
    * @return {number}
    */
   get startOffset() {
-    return this.value_.getSpanStart(this.start_) + this.start_.index;
+    // It is possible that the start cursor points to content before this line
+    // (e.g. in a multi-line selection).
+    try {
+      return this.value_.getSpanStart(this.start_) + this.start_.index;
+    } catch (e) {
+      // When that happens, fall back to the start of this line.
+      return 0;
+    }
   },
 
   /**
    * Gets the selection offset based on the text content of this line.
    * @return {number}
    */
   get endOffset() {
-    return this.value_.getSpanStart(this.end_) + this.end_.index;
+    try {
+      return this.value_.getSpanStart(this.end_) + this.end_.index;
+    } catch (e) {
+      return this.value_.length - 1;
+    }
   },
 
   /**
    * Gets the selection offset based on the parent's text.
    * The parent is expected to be static text.
    * @return {number}
    */
   get localStartOffset() {
     return this.startOffset - this.containerStartOffset;
   },
@@ skipping 27 matching lines @@
 
   /**
    * The text content of this line.
    * @return {string} The text of this line.
    */
   get text() {
     return this.value_.toString();
   },
 
   /**
+   *
+   */
+  equalsStart: function(otherLine) {
+    return otherLine.lineStartContainer_ == this.lineStartContainer_ &&
+        otherLine.localLineStartContainerOffset_ ==
+        this.localLineStartContainerOffset_;
+  },
+
+  equalsEnd: function(otherLine) {
+    return otherLine.lineEndContainer_ == this.lineEndContainer_ &&
+        otherLine.localLineEndContainerOffset_ ==
+        this.localLineEndContainerOffset_;
+  },
+
+  /**
    * Returns true if |otherLine| surrounds the same line as |this|. Note that
    * the contents of the line might be different.
    * @return {boolean}
    */
   equals: function(otherLine) {
     // Equality is intentionally loose here as any of the state nodes can be
     // invalidated at any time. We rely upon the start/anchor of the line
     // staying the same.
-    return otherLine.lineStartContainer_ == this.lineStartContainer_ &&
-        otherLine.localLineStartContainerOffset_ ==
-            this.localLineStartContainerOffset_;
+    return this.equalsStart(otherLine) || this.equalsEnd(otherLine);
+  },
+
+  strictEquals: function(otherLine) {
+    return this.equals(otherLine) &&
+        this.startOffset == otherLine.startOffset &&
+        this.endOffset == otherLine.endOffset;
   }
 };
 
 });