Send backspace to ChromeVox from Braille IME.

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.
  * {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: '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() {};
 
 BrailleIme.prototype = {
   /**
    * Whether to enable extra debug logging for the IME.
@@ skipping 81 matching lines @@
   /**
    * 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));
+    chrome.input.ime.onKeyEvent.addListener(this.onKeyEvent_.bind(this),
+                                            ['async']);
     chrome.input.ime.onReset.addListener(this.onReset_.bind(this));
     chrome.input.ime.onMenuItemActivated.addListener(
         this.onMenuItemActivated_.bind(this));
     this.connectChromeVox_();
   },
 
   /**
    * Called by the IME framework when this IME is activated.
    * @param {string} engineID Engine ID, should be 'braille'.
    * @private
@@ skipping 50 matching lines @@
    */
   onInputContextUpdate_: function(context) {
     this.log_('onInputContextUpdate', JSON.stringify(context));
     this.sendInputContext_(context);
   },
 
   /**
    * 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.
-   * @return {boolean} Whether the event was handled by this IME (true) or
-   *     should be allowed to propagate.
    * @private
    */
   onKeyEvent_: function(engineID, event) {
     this.log_('onKeyEvent', engineID + ', ' + JSON.stringify(event));
-    return this.processKey_(event);
+    var result = this.processKey_(event);
+    if (result !== undefined) {
+      chrome.input.ime.keyEventHandled(event.requestId, 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 32 matching lines @@
       return;
     }
     if (this.DEBUG) {
       console.log('BrailleIme.' + func + ': ' + message);
     }
   },
 
   /**
    * Handles a qwerty key on the home row as a braille key.
    * @param {!ChromeKeyboardEvent} event Keyboard event.
-   * @return {boolean} Whether the key event was handled or not.
+   * @return {boolean|undefined} Whether the event was handled, or
+   *     {@code undefined} if handling was delegated to ChromeVox.
    * @private
    */
   processKey_: function(event) {
     if (!this.useStandardKeyboard_) {
       return false;
     }
+    if (event.code === 'Backspace' && event.type === 'keydown') {
+      this.pressed_ = 0;
+      this.accumulated_ = 0;
+      this.sendToChromeVox_(
+          {type: 'backspace', requestId: event.requestId});
+      return undefined;
+    }
     var dot = this.CODE_TO_DOT_[event.code];
     if (!dot || event.altKey || event.ctrlKey || event.shiftKey ||
         event.capsLock) {
       this.pressed_ = 0;
       this.accumulated_ = 0;
       return false;
     }
     if (event.type === 'keydown') {
       this.pressed_ |= dot;
       this.accumulated_ |= this.pressed_;
@@ skipping 47 matching lines @@
       case 'replaceText':
         message =
             /**
              * @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);
+        break;
+      default:
+        console.error('Unknown message from ChromeVox: ' +
+            JSON.stringify(message));
+        break;
     }
   },
 
   /**
    * Handles a disconnect event from the ChromeVox side.
    * @private
    */
   onChromeVoxDisconnect_: function() {
     this.port_ = null;
     this.log_('onChromeVoxDisconnect',
@@ skipping 32 matching lines @@
 
   /**
    * Replaces text in the current text field.
    * @param {number} contextID Context for the input field to replace the
    *     text in.
    * @param {number} deleteBefore How many characters to delete before the
    *     cursor.
    * @param {string} toInsert Text to insert at the cursor.
    */
   replaceText_: function(contextID, deleteBefore, toInsert) {
+    console.log('replaceText: ' + deleteBefore + ',' + toInsert);

[David Tseng, 2014/06/19 21:30:16]

nit: Remove

     var addText = function() {
       chrome.input.ime.commitText(
           {contextID: contextID, text: toInsert});
     }.bind(this);
     if (deleteBefore > 0) {
       var deleteText = function() {
         chrome.input.ime.deleteSurroundingText(
             {engineID: this.engineID_, contextID: contextID,
              offset: -deleteBefore, length: deleteBefore}, addText);
       }.bind(this);
@@ skipping 20 matching lines @@
              label: 'Use standard keyboard for braille',
              style: 'check',
              visible: true,
              checked: this.useStandardKeyboard_,
              enabled: true
              }
          ]
         });
   }
 };