Make contracted braille input work in more contexts.

chrome/browser/resources/chromeos/chromevox/braille/braille_input_handler.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 Handles braille input keys when the user is typing or editing
  * text in an input field.  This class cooperates with the Braille IME
  * that is built into Chrome OS to do the actual text editing.
  */
 
@@ skipping 55 matching lines @@
    * the race, we store the cell entered until we can submit it to the IME.
    * @type {!Array<number>}
    * @private
    */
   this.pendingCells_ = [];
   /**
    * @type {cvox.BrailleInputHandler.EntryState_}
    * @private
    */
   this.entryState_ = null;
+  /**
+   * @type {cvox.ExtraCellsSpan}
+   * @private
+   */
+  this.uncommittedCellsSpan_ = null;
+  /**
+   * @type {function()?}
+   * @private
+   */
+  this.uncommittedCellsChangedListener_ = null;
 
   this.translatorManager_.addChangeListener(
-      this.clearEntryState_.bind(this));
+      this.commitAndClearEntryState_.bind(this));
 };
 
 /**
  * The ID of the Braille IME extension built into Chrome OS.
  * @const {string}
  * @private
  */
 cvox.BrailleInputHandler.IME_EXTENSION_ID_ =
     'jddehjeebkoimngcbdkaahpobgicbffp';
 
@@ skipping 26 matching lines @@
    */
   init: function() {
     chrome.runtime.onConnectExternal.addListener(this.onImeConnect_.bind(this));
   },
 
   /**
    * Called when the content on the braille display is updated.  Modifies the
    * input state according to the new content.
    * @param {cvox.Spannable} text Text, optionally with value and selection
    *     spans.
+   * @param {function()} listener Called when the uncommitted cells
+   *     have changed.
    */
-  onDisplayContentChanged: function(text) {
+  onDisplayContentChanged: function(text, listener) {
     var valueSpan = text.getSpanInstanceOf(cvox.ValueSpan);
     var selectionSpan = text.getSpanInstanceOf(cvox.ValueSelectionSpan);
     if (!(valueSpan && selectionSpan))
       return;
+    // Don't call the old listener any further, since new content is being
+    // set.  If the old listener is not cleared here, it could be called
+    // spuriously if the entry state is cleared below.
+    this.uncommittedCellsChangedListener_ = null;
     // The type casts are ok because the spans are known to exist.
     var valueStart = /** @type {number} */ (text.getSpanStart(valueSpan));
     var valueEnd = /** @type {number} */ (text.getSpanEnd(valueSpan));
     var selectionStart =
         /** @type {number} */ (text.getSpanStart(selectionSpan));
     var selectionEnd = /** @type {number} */ (text.getSpanEnd(selectionSpan));
     if (selectionStart < valueStart || selectionEnd > valueEnd) {
       console.error('Selection outside of value in braille content');
       this.clearEntryState_();
       return;
     }
     var newTextBefore = text.toString().substring(valueStart, selectionStart);
     if (this.currentTextBefore_ !== newTextBefore && this.entryState_)
       this.entryState_.onTextBeforeChanged(newTextBefore);
     this.currentTextBefore_ = newTextBefore;
     this.currentTextAfter_ = text.toString().substring(selectionEnd, valueEnd);
+    this.uncommittedCellsSpan_ = new cvox.ExtraCellsSpan();
+    text.setSpan(this.uncommittedCellsSpan_, selectionStart, selectionStart);
+    if (this.entryState_ && this.entryState_.usesUncommittedCells) {
+      this.updateUncommittedCells_(
+          new Uint8Array(this.entryState_.cells_).buffer);
+    }
+    this.uncommittedCellsChangedListener_ = listener;
   },
 
   /**
    * Handles braille key events used for input by editing the current input
    * field appropriately.
    * @param {!cvox.BrailleKeyEvent} event The key event.
    * @return {boolean} {@code true} if the event was handled, {@code false}
    *     if it should propagate further.
    */
   onBrailleKeyEvent: function(event) {
     if (event.command === cvox.BrailleKeyCommand.DOTS)
       return this.onBrailleDots_(/** @type {number} */(event.brailleDots));
     // Any other braille command cancels the pending cells.
     this.pendingCells_.length = 0;
     if (event.command === cvox.BrailleKeyCommand.STANDARD_KEY) {
       if (event.standardKeyCode === 'Backspace' &&
           !event.altKey && !event.ctrlKey && !event.shiftKey &&
           this.onBackspace_()) {
         return true;
       } else {
-        this.clearEntryState_();
+        this.commitAndClearEntryState_();
         this.sendKeyEventPair_(event);
         return true;
       }
     }
     return false;
   },
 
   /**
    * Returns how the value of the currently displayed content should be
    * expanded given the current input state.
@@ skipping 28 matching lines @@
    *    propagate further.
    * @private
    */
   onBrailleDots_: function(dots) {
     if (!this.imeActive_) {
       this.pendingCells_.push(dots);
       return true;
     }
     if (!this.inputContext_)
       return false;
-    // Avoid accumulating cells forever when typing without moving the cursor
-    // by flushing the input when we see a blank cell.
-    // Note that this might switch to contracted if appropriate.
-    if (this.entryState_ && this.entryState_.lastCellIsBlank())
-      this.clearEntryState_();
     if (!this.entryState_) {
-      this.entryState_ = this.createEntryState_();
-      if (!this.entryState_)
+      if (!(this.entryState_ = this.createEntryState_()))
         return false;
     }
     this.entryState_.appendCell(dots);
     return true;
   },
 
   /**
    * Handles the backspace key by deleting the last typed cell if possible.
    * @return {boolean} {@code true} if the event was handled, {@code false}
    *     if it wasn't and should propagate further.
@@ skipping 14 matching lines @@
    *     object, or null if it couldn't be created (e.g. if there's no braille
    *     translator available yet).
    * @private
    */
   createEntryState_: function() {
     var translator = this.translatorManager_.getDefaultTranslator();
     if (!translator)
       return null;
     var uncontractedTranslator =
         this.translatorManager_.getUncontractedTranslator();
+    var constructor = cvox.BrailleInputHandler.EditsEntryState_;
     if (uncontractedTranslator) {
       var textBefore = this.currentTextBefore_;
       var textAfter = this.currentTextAfter_;
       if (this.inAlwaysUncontractedContext_() ||
           (cvox.BrailleInputHandler.ENDS_WITH_NON_WHITESPACE_RE_.test(
               textBefore)) ||
           (cvox.BrailleInputHandler.STARTS_WITH_NON_WHITESPACE_RE_.test(
               textAfter))) {
         translator = uncontractedTranslator;
+      } else {
+        constructor = cvox.BrailleInputHandler.LateCommitEntryState_;
       }
     }
 
-    return new cvox.BrailleInputHandler.EditsEntryState_(this, translator);
+    return new constructor(this, translator);
   },
 
   /**
+   * Commits the current entry state and clears it, if any.
+   * @private
+   */
+  commitAndClearEntryState_: function() {
+    if (this.entryState_) {
+      this.entryState_.commit();
+      this.clearEntryState_();
+    }
+  },
+
+  /**
    * Clears the current entry state without committing it.
    * @private
    */
   clearEntryState_: function() {
     if (this.entryState_) {
+      if (this.entryState_.usesUncommittedCells)
+        this.updateUncommittedCells_(new ArrayBuffer(0));
       this.entryState_.inputHandler_ = null;
       this.entryState_ = null;
     }
   },
 
   /**
+   * @param {ArrayBuffer} cells
+   * @private
+   */
+  updateUncommittedCells_: function(cells) {
+    if (this.uncommittedCellsSpan_)
+      this.uncommittedCellsSpan_.cells = cells;
+    if (this.uncommittedCellsChangedListener_)
+      this.uncommittedCellsChangedListener_();
+  },
+
+  /**
    * Called when another extension connects to this extension.  Accepts
    * connections from the ChromeOS builtin Braille IME and ignores connections
    * from other extensions.
    * @param {Port} port The port used to communicate with the other extension.
    * @private
    */
   onImeConnect_: function(port) {
     if (port.name !== cvox.BrailleInputHandler.IME_PORT_NAME_ ||
         port.sender.id !== cvox.BrailleInputHandler.IME_EXTENSION_ID_) {
       return;
@@ skipping 197 matching lines @@
         // Delete all previous expected changes and ignore this one.
         this.pendingTextsBefore_.splice(0, i + 1);
         return;
       }
     }
     // There was an actual text change (or cursor movement) that we hadn't
     // caused ourselves, reset any pending input.
     this.inputHandler_.clearEntryState_();
   },
 
-  /** @return {boolean} */
-  lastCellIsBlank: function() {
-    return this.cells_[this.cells_.length - 1] === 0;
+  /**
+   * Makes sure the current text is permanently added to the edit field.
+   * After this call, this object should be abandoned.
+   */
+  commit: function() {
   },
 
   /**
+   * @return {boolean} true if the entry state uses uncommitted cells.
+   */
+  get usesUncommittedCells() {
+    return false;
+  },
+
+  /**
    * Updates the translated text based on the current cells and sends the
    * delta to the IME.
    * @private
    */
   updateText_: function() {
     var cellsBuffer = new Uint8Array(this.cells_).buffer;
+    var commit = this.lastCellIsBlank_;
+    if (!commit && this.usesUncommittedCells)
+      this.inputHandler_.updateUncommittedCells_(cellsBuffer);
     this.translator_.backTranslate(cellsBuffer, function(result) {
       if (result === null) {
         console.error('Error when backtranslating braille cells');
         return;
       }
       if (!this.inputHandler_)
         return;
       this.sendTextChange_(result);
       this.text_ = result;
+      if (commit)
+        this.inputHandler_.commitAndClearEntryState_();
     }.bind(this));
   },
 
   /**
+   * @return {boolean}
+   * @private
+   */
+  get lastCellIsBlank_() {
+    return this.cells_[this.cells_.length - 1] === 0;
+  },
+
+  /**
    * Sends new text to the IME.  This dhould be overriden by subclasses.
    * The old text is still available in the {@code text_} property.
    * @param {string} newText Text to send.
    * @private
    */
   sendTextChange_: function(newText) {
   }
 };
 
 /**
@@ skipping 41 matching lines @@
       }
       // Send the replace operation to be performed asynchronously by the IME.
       this.inputHandler_.postImeMessage_(
           {type: 'replaceText',
            contextID: this.inputHandler_.inputContext_.contextID,
            deleteBefore: deleteLength,
            newText: toInsert});
     }
   }
 };
+
+/**
+ * Entry state that only updates the edit field when a blank cell is entered.
+ * During the input of a single 'word', the uncommitted text is stored by the
+ * IME.
+ * @param {!cvox.BrailleInputHandler} inputHandler
+ * @param {!cvox.LibLouis.Translator} translator
+ * @constructor
+ * @private
+ * @extends {cvox.BrailleInputHandler.EntryState_}
+ */
+cvox.BrailleInputHandler.LateCommitEntryState_ = function(
+    inputHandler, translator) {
+  cvox.BrailleInputHandler.EntryState_.call(this, inputHandler, translator);
+};
+
+cvox.BrailleInputHandler.LateCommitEntryState_.prototype = {
+  __proto__: cvox.BrailleInputHandler.EntryState_.prototype,
+
+  /** @override */
+  commit: function() {
+    this.inputHandler_.postImeMessage_(
+        {type: 'commitUncommitted',
+         contextID: this.inputHandler_.inputContext_.contextID});
+  },
+
+  /** @override */
+  get usesUncommittedCells() {
+    return true;
+  },
+
+  /** @override */
+  sendTextChange_: function(newText) {
+    this.inputHandler_.postImeMessage_(
+        {type: 'setUncommitted',
+         contextID: this.inputHandler_.inputContext_.contextID,
+         text: newText});
+  }
+};