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
@@ skipping 112 matching lines @@
    */
   engineID_: '',
 
   /**
    * The port used to communicate with ChromeVox.
    * @type {Port} port_
    * @private
    */
   port_: null,
 
+  // state of the current composition, if any.  This is kep here so that
+  // the composition can be committed on key presses.
+
+  /** @type {number} */

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

nit: @private; also, perhaps combine these two members into one object.

+  compositionContextID_: 0,
+
+  /** @type {string} */
+  compositionText_: '',
+
   /**
    * 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));
@@ skipping 67 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);
+      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);
@@ skipping 118 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 'setComposition':
+        message =
+            /** @type {{contextID: number, text: string}} */ (message);
+        this.setComposition_(message.contextID, message.text);
+        break;
+      case 'commitComposition':
+        message =
+            /** @type {{contextID: number}} */ (message);
+        this.commitComposition_(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 outstanding composition text is
+   * committed before sending the response to the IME API.
+   * @param {string} requestId Key even request id.

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

nit: Key event

+   * @param {string} type Type of key event being responded to.
+   * @param {boolean} response Wether the IME handled theevent.

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

nit: whether ... the event

+   */
+  keyEventHandled_: function(requestId, type, response) {
+    if (!response && type === 'keydown' && this.compositionText_) {
+      this.commitComposition_();
+      this.sendToChromeVox_({type: 'reset'});
+    }
+    chrome.input.ime.keyEventHandled(requestId, response);
+  },
+
+  /**
+   * Calls the correspnding IME API function and stores the current

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

nit: corresponding

+   * composition.
+   * @param {number} contextID
+   * @param {string} text
+   */
+  setComposition_: function(contextID, text) {
+    chrome.input.ime.setComposition({contextID: contextID,
+                                     text: text,
+                                     cursor: text.length});
+    this.compositionContextID_ = contextID;
+    this.compositionText_ = text;
+  },
+
+  /**
+   * Commits the last set composition if it mathces the given context id.

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

nit: matches

+   * @param {number=} opt_contextID
+   */
+  commitComposition_: function(opt_contextID) {
+    if (opt_contextID === undefined ||

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

Why is this optional?

+        opt_contextID === this.compositionContextID_) {
+      chrome.input.ime.commitText({contextID: this.compositionContextID_,
+                                   text: this.compositionText_});
+    }
+    this.compositionText_ = '';
+    this.compositionContextID_ = 0;
+  },
+
+  /**
    * 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
              }
          ]
         });
   }
 };