Make character text changes work in Docs

chrome/browser/resources/chromeos/chromevox/cvox2/background/cursors.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 Classes related to cursors that point to and select parts of
  * the automation tree.
  */
 
 goog.provide('cursors.Cursor');
@@ skipping 66 matching lines @@
 cursors.Cursor = function(node, index) {
   // Compensate for specific issues in Blink.
   // TODO(dtseng): Pass through affinity; if upstream, skip below.
   if (node.role == RoleType.STATIC_TEXT && node.name.length == index) {
     // Re-interpret this case as the beginning of the next node.
     var nextNode = AutomationUtil.findNextNode(
         node, Dir.FORWARD, AutomationPredicate.leafOrStaticText);
 
     // The exception is when a user types at the end of a line. In that case,
     // staying on the current node is appropriate.
-    if (node && node.nextOnLine && nextNode) {
+    if (node && node.nextOnLine && node.nextOnLine.role && nextNode) {
       node = nextNode;
       index = 0;
     }
   } else if (
       node.role == RoleType.GENERIC_CONTAINER && node.state.richlyEditable &&
       (node.firstChild &&
        (node.firstChild.role == RoleType.LINE_BREAK ||
         node.firstChild.role == RoleType.STATIC_TEXT))) {
     // Re-interpret this case as pointing to the text under the div.
     node = node.find({role: RoleType.INLINE_TEXT_BOX}) || node;
   }
 
   /** @type {number} @private */
   this.index_ = index;
   /** @type {Array<AutomationNode>} @private */
   this.ancestry_ = [];
+  /** @type {!Array<number>} @private */
+  this.recoveryChildIndex_ = [];
+
   var nodeWalker = node;
   while (nodeWalker) {
     this.ancestry_.push(nodeWalker);
+    this.recoveryChildIndex_.push(nodeWalker.indexInParent);

[dmazzoni, 2017/07/06 21:17:06]

I like this idea in general but how about a tiny bit of
redundant information, in order to avoid "recovering"
a completely unrelated part of the document?

I'm thinking something like saving the role and name for
every item in the hierarchy in addition to its index in
parent - then the recovery could reject something that's
clearly the wrong node. In the future we could consider
making it smart about a fuzzy match - but that's beyond
the scope for now.

Also, how about abstracting this idea into a general
helper class outside of cursor or editable text?
We should use something similar to save and restore
your position within a document when reloading a page,
for example.

[David Tseng, 2017/07/06 22:15:44]

I'm actually something slightly different here that requires the Cursor class.

From experience, saving the absolute screen x, y position gives a better
recovery for web pages. Tree paths perform really poorly from what I've seen in
general so I do think we want it only for editing and specifically for line
comparisons. I can move it out of Cursor, but I also put it there since it has
both a node and index member. The index member helps restrict the possible false
positives since a static text often has soft line wraps so we want to correctly
account for that. Given two soft lines, we don't want to consider them the same
line even if all roles/tree paths matched but the local line start container
offsets don't.

     nodeWalker = nodeWalker.parent;
     if (nodeWalker && nodeWalker.role == RoleType.WINDOW)
       break;
   }
 };
 
 /**
  * Convenience method to construct a Cursor from a node.
  * @param {!AutomationNode} node
  * @return {!cursors.Cursor}
@@ skipping 66 matching lines @@
           firstValidNode.root != undefined) {
         return firstValidNode;
       }
       // If we have to walk up to an ancestor, reset the index to NODE_INDEX.
       this.index_ = cursors.NODE_INDEX;
     }
     return null;
   },
 
   /**
+   * Returns the node. If the node is invalid since the last time it
+   * was accessed, attempts to recover it based on a child index.
+   * @return {AutomationNode}
+   */
+  get recoveryNode() {
+    for (var i = 0; i < this.ancestry_.length; i++) {
+      var firstValidNode = this.ancestry_[i];
+      if (firstValidNode != null && firstValidNode.role !== undefined &&
+          firstValidNode.root != undefined) {
+        if (i == 0)
+          return firstValidNode;
+
+        // Otherwise, attempt to recover.
+        var node = firstValidNode;
+        for (var j = i - 1; j >= 0; j--) {
+          var index = this.recoveryChildIndex_[j];
+          var children = node.children;
+          if (!children[index])
+            return node;
+          node = children[index];
+        }
+        return node;
+      }
+    }
+    return null;
+  },
+
+  /**
    * @return {number}
    */
   get index() {
     return this.index_;
   },
 
 
   /**
    * A node appropriate for making selections.
    * @return {AutomationNode}
@@ skipping 564 matching lines @@
   /**
    * Returns whether this range has valid start and end cursors.
    * @return {boolean}
    */
   isValid: function() {
     return this.start.isValid() && this.end.isValid();
   }
 };
 
 });  // goog.scope