Make contracted braille input work in more contexts.

chrome/browser/resources/chromeos/braille_ime/braille_ime.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.
 
 'use strict';
 
 /**
  * @fileoverview Braille hardware keyboard input method.
  *
  * This method is automatically enabled when a braille display is connected
  * and ChromeVox is turned on.  Most of the braille input and editing logic
  * is located in ChromeVox where the braille translation library is available.
  * This IME connects to ChromeVox and communicates using messages as follows:
  *
  * Sent from this IME to ChromeVox:
  * {type: 'activeState', active: boolean}
  * {type: 'inputContext', context: InputContext}
  *   Sent on focus/blur to inform ChromeVox of the type of the current field.
  *   In the latter case (blur), context is null.
  * {type: 'reset'}
- *   Sent when the {@code onReset} IME event fires.
+ *   Sent when the {@code onReset} IME event fires or uncommitted text is
+ *   committed without being triggered by ChromeVox (e.g. because of a
+ *   key press).
  * {type: 'brailleDots', dots: number}
  *   Sent when the user typed a braille cell using the standard keyboard.
  *   ChromeVox treats this similarly to entering braille input using the
  *   braille display.
  * {type: 'backspace', requestId: string}
  *   Sent when the user presses the backspace key.
  *   ChromeVox must respond with a {@code keyEventHandled} message
  *   with the same request id.
  *
  * Sent from ChromeVox to this IME:
  * {type: 'replaceText', contextID: number, deleteBefore: number,
  *  newText: string}
  *   Deletes {@code deleteBefore} characters before the cursor (or selection)
  *   and inserts {@code newText}.  {@code contextID} identifies the text field
  *   to apply the update to (no change will happen if focus has moved to a
  *   different field).
+ * {type: 'setUncommitted', contextID: number, text: string}
+ *   Stores text for the field identified by contextID to be committed
+ *   either as a result of a 'commitUncommitted' message or a by the IME
+ *   unhandled key press event.  Unlike 'replaceText', this does not send the
+ *   uncommitted text to the input field, but instead stores it in the IME.
+ * {type: 'commitUncommitted', contextID: number}
+ *   Commits any uncommitted text if it matches the given context ID.
+ *   See 'setUncommitted' above.
  * {type: 'keyEventHandled', requestId: string, result: boolean}
  *   Response to a {@code backspace} message indicating whether the
  *   backspace was handled by ChromeVox or should be allowed to propagate
  *   through the normal event handling pipeline.
  */
 
 /**
  * @constructor
  */
 var BrailleIme = function() {};
@@ skipping 76 matching lines @@
   engineID_: '',
 
   /**
    * The port used to communicate with ChromeVox.
    * @type {Port} port_
    * @private
    */
   port_: null,
 
   /**
+   * Uncommitted text and context ID.
+   * @type {?{contextID: number, text: string}}
+   * @private
+   */
+  uncommitted_: null,
+
+  /**
    * Registers event listeners in the chrome IME API.
    */
   init: function() {
     chrome.input.ime.onActivate.addListener(this.onActivate_.bind(this));
     chrome.input.ime.onDeactivated.addListener(this.onDeactivated_.bind(this));
     chrome.input.ime.onFocus.addListener(this.onFocus_.bind(this));
     chrome.input.ime.onBlur.addListener(this.onBlur_.bind(this));
     chrome.input.ime.onInputContextUpdate.addListener(
         this.onInputContextUpdate_.bind(this));
     chrome.input.ime.onKeyEvent.addListener(this.onKeyEvent_.bind(this),
@@ skipping 65 matching lines @@
   },
 
   /**
    * Called by the system when this IME is active and a key event is generated.
    * @param {string} engineID Engine ID, should be 'braille'.
    * @param {!ChromeKeyboardEvent} event The keyboard event.
    * @private
    */
   onKeyEvent_: function(engineID, event) {
     var result = this.processKey_(event);
-    if (result !== undefined) {
-      chrome.input.ime.keyEventHandled(event.requestId, result);
-    }
+    if (result !== undefined)
+      this.keyEventHandled_(event.requestId, event.type, result);
   },
 
   /**
    * Called when chrome ends the current text input session.
    * @param {string} engineID Engine ID, should be 'braille'.
    * @private
    */
   onReset_: function(engineID) {
     this.log_('onReset', engineID);
     this.engineID_ = engineID;
@@ skipping 117 matching lines @@
              * @type {{contextID: number, deleteBefore: number,
              *         newText: string}}
              */
             (message);
         this.replaceText_(message.contextID, message.deleteBefore,
                           message.newText);
         break;
       case 'keyEventHandled':
         message =
             /** @type {{requestId: string, result: boolean}} */ (message);
-        chrome.input.ime.keyEventHandled(message.requestId, message.result);
+        this.keyEventHandled_(message.requestId, 'keydown', message.result);
+        break;
+      case 'setUncommitted':
+        message =
+            /** @type {{contextID: number, text: string}} */ (message);
+        this.setUncommitted_(message.contextID, message.text);
+        break;
+      case 'commitUncommitted':
+        message =
+            /** @type {{contextID: number}} */ (message);
+        this.commitUncommitted_(message.contextID);
         break;
       default:
         console.error('Unknown message from ChromeVox: ' +
             JSON.stringify(message));
         break;
     }
   },
 
   /**
    * Handles a disconnect event from the ChromeVox side.
@@ skipping 53 matching lines @@
       // deleteSurroundingText works correctly.
       chrome.input.ime.deleteSurroundingText(
           {engineID: this.engineID_, contextID: contextID,
            offset: 0, length: 0}, deleteText);
     } else {
       addText();
     }
   },
 
   /**
+   * Responds to an asynchronous key event, indicating whether it was handled
+   * or not.  If it wasn't handled, any uncommitted text is committed
+   * before sending the response to the IME API.
+   * @param {string} requestId Key event request id.
+   * @param {string} type Type of key event being responded to.
+   * @param {boolean} response Whether the IME handled the event.
+   */
+  keyEventHandled_: function(requestId, type, response) {
+    if (!response && type === 'keydown' && this.uncommitted_) {
+      this.commitUncommitted_(this.uncommitted_.contextID);
+      this.sendToChromeVox_({type: 'reset'});
+    }
+    chrome.input.ime.keyEventHandled(requestId, response);
+  },
+
+  /**
+   * Stores uncommitted text that will be committed on any key press or
+   * when {@code commitUncommitted_} is called.
+   * @param {number} contextID of the current field.
+   * @param {string} text to store.
+   */
+  setUncommitted_: function(contextID, text) {
+    this.uncommitted_ = {contextID: contextID, text: text};
+  },
+
+  /**
+   * Commits the last set uncommitted text if it matches the given context id.
+   * @param {number} contextID
+   */
+  commitUncommitted_: function(contextID) {
+    if (this.uncommitted_ && contextID === this.uncommitted_.contextID)
+      chrome.input.ime.commitText(this.uncommitted_);
+    this.uncommitted_ = null;
+  },
+
+  /**
    * Updates the menu items for this IME.
    */
   updateMenuItems_: function() {
     // TODO(plundblad): Localize when translations available.
     chrome.input.ime.setMenuItems(
         {engineID: this.engineID_,
          items: [
            {
              id: this.USE_STANDARD_KEYBOARD_ID,
              label: 'Use standard keyboard for braille',
              style: 'check',
              visible: true,
              checked: this.useStandardKeyboard_,
              enabled: true
              }
          ]
         });
   }
 };