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 57 matching lines @@
    * @private
    */
   this.pendingCells_ = [];
   /**
    * @type {cvox.BrailleInputHandler.EntryState_}
    * @private
    */
   this.entryState_ = 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 55 matching lines @@
       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 37 matching lines @@
       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_();
+      this.commitAndClearEntryState_();
     }
     if (!this.entryState_) {
       this.entryState_ = this.createEntryState_();
       if (!this.entryState_) {
         return false;
       }
     }
     this.entryState_.appendCell(dots);
     return true;
   },
@@ skipping 20 matching lines @@
    *     translator available yet).
    * @private
    */
   createEntryState_: function() {
     var translator = this.translatorManager_.getDefaultTranslator();
     if (!translator) {
       return null;
     }
     var uncontractedTranslator =
         this.translatorManager_.getUncontractedTranslator();
+    var useComposition = false;
     if (uncontractedTranslator) {
       var textBefore = this.currentTextBefore_;
       var textAfter = this.currentTextAfter_;
       if (this.inAlwaysUncontractedContext_() ||
           (textBefore.length > 0 && /\S$/.test(textBefore)) ||
           (textAfter.length > 0 && /^\S/.test(textAfter))) {
         translator = uncontractedTranslator;
+      } else {
+        useComposition = true;
       }
     }
 
-    return new cvox.BrailleInputHandler.EditsEntryState_(this, translator);
+    useComposition = false;

[David Tseng, 2015/03/30 17:13:44]

This looks wrong.

+    if (useComposition) {
+      return new cvox.BrailleInputHandler.CompositionEntryState_(
+          this, translator);
+    } else {
+      return new cvox.BrailleInputHandler.EditsEntryState_(
+          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 comitting it.
    * @private
    */
   clearEntryState_: function() {
     if (this.entryState_) {
       this.entryState_.inputHandler_ = null;
       this.entryState_ = null;
     }
   },
 
@@ skipping 211 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_();
   },
 
+  /**
+   * Makes sure the current text is permanently added to the edit field.
+   * After this call, this object should be abandoned.
+   */
+  commit: function() {
+  },
+
   /** @return {boolean} */
   lastCellIsBlank: function() {
     return this.cells_[this.cells_.length - 1] === 0;
   },
 
   /**
    * Updates the translated text based on the current cells and sends the
    * delta to the IME.
    * @private
    */
@@ skipping 67 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 uses the IME composition API to update the edit field.
+ * @param {!cvox.BrailleInputHandler} inputHandler
+ * @param {!cvox.LibLouis.Translator} translator
+ * @constructor
+ * @private
+ * @extends {cvox.BrailleInputHandler.EntryState_}
+ */
+cvox.BrailleInputHandler.CompositionEntryState_ = function(
+    inputHandler, translator) {
+  cvox.BrailleInputHandler.EntryState_.call(this, inputHandler, translator);
+};
+
+cvox.BrailleInputHandler.CompositionEntryState_.prototype = {
+  __proto__: cvox.BrailleInputHandler.EntryState_,
+
+  /** @override */
+  commit: function() {
+    this.inputHandler_.postImeMessage_(
+        {type: 'commitComposition',
+         contextID: this.inputHandler_.inputContext_.contextID});
+  },
+
+  /** @override */
+  sendTextChange_: function(newText) {
+    var currentTextBefore = this.inputHandler_.currentTextBefore_;
+    var oldText = this.text_;
+    this.pendingTextsBefore_.push(currentTextBefore.substring(
+        0, currentTextBefore.length - oldText.length) + newText);
+    this.inputHandler_.postImeMessage_(
+        {type: 'setComposition',
+         contextID: this.inputHandler_.inputContext_.contextID,
+         text: newText});
+  }
+};