Make character text changes work in Docs

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('TreePathRecoveryStrategy');
 goog.require('cursors.Cursor');
 goog.require('cursors.Range');
 goog.require('cvox.BrailleBackground');
 goog.require('cvox.ChromeVoxEditableTextBase');
 goog.require('cvox.LibLouis.FormType');
 
 goog.scope(function() {
 var AutomationEvent = chrome.automation.AutomationEvent;
 var AutomationNode = chrome.automation.AutomationNode;
 var Cursor = cursors.Cursor;
@@ skipping 628 matching lines @@
   /** @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;
+  /** @type {RecoveryStrategy} */
+  this.lineStartContainerRecovery_;
 
   this.computeLineData_(opt_baseLineOnStart);
 };
 
 editing.EditableLine.prototype = {
   /** @private */
   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
@@ skipping 85 matching lines @@
     // 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;
 
+    if (this.lineStartContainer_) {
+      this.lineStartContainerRecovery_ =
+          new TreePathRecoveryStrategy(this.lineStartContainer_);
+    }
+
     finder = this.lineEnd_;
     while (finder.nextSibling) {
       finder = finder.nextSibling;
       textCountAfterLineEnd += finder.name.length;
     }
 
     if (this.lineEndContainer_.name) {
       this.localLineEndContainerOffset_ =
           this.lineEndContainer_.name.length - textCountAfterLineEnd;
     }
@@ skipping 122 matching lines @@
    */
   isSameLine: 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_) ||
         (otherLine.lineEndContainer_ == this.lineEndContainer_ &&
          otherLine.localLineEndContainerOffset_ ==
-             this.localLineEndContainerOffset_);
+             this.localLineEndContainerOffset_) ||
+        (otherLine.lineStartContainerRecovery_.node ==
+             this.lineStartContainerRecovery_.node &&
+         otherLine.localLineStartContainerOffset_ ==
+             this.localLineStartContainerOffset_);
   },
 
   /**
    * Returns true if |otherLine| surrounds the same line as |this| and has the
    * same selection.
    * @param {editing.EditableLine} otherLine
    * @return {boolean}
    */
   isSameLineAndSelection: function(otherLine) {
     return this.isSameLine(otherLine) &&
         this.startOffset == otherLine.startOffset &&
         this.endOffset == otherLine.endOffset;
   },
 
   /**
    * Returns whether this line comes before |otherLine| in document order.
    * @return {boolean}
    */
   isBeforeLine: function(otherLine) {
     if (this.isSameLine(otherLine) || !this.lineStartContainer_ ||
         !otherLine.lineStartContainer_)
       return false;
     return AutomationUtil.getDirection(
                this.lineStartContainer_, otherLine.lineStartContainer_) ==
         Dir.FORWARD;
   }
 };
 
 });