Make Braille IME send space bar as an empty cell instead of letting propagate.

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 51 matching lines @@
 
   /**
    * Identifier for the use standard keyboard option used in the menu and
    * {@code localStorage}.  This can be switched on to type braille using the
    * standard keyboard, or off (default) for the usual keyboard behaviour.
    * @const {string}
    */
   USE_STANDARD_KEYBOARD_ID: 'useStandardKeyboard',
 
   // State related to the support for typing braille using a standrad
-  // (querty) keyboard.
+  // (qwerty) keyboard.
 
   /** @private {boolean} */
   useStandardKeyboard_: false,
 
   /**
    * Braille dots for keys that are currently pressed.
    * @private {number}
    */
   pressed_: 0,
 
   /**
    * Dots that have been pressed at some point since {@code pressed_} was last
    * {@code 0}.
    * @private {number}
    */
   accumulated_: 0,
 
   /**
+   * Bit in {@code pressed_} and {@code accumulated_} that represent
+   * the space key.
+   * @const {number}
+   */
+  SPACE: 0x100,
+
+  /**
    * Maps key codes on a standard keyboard to the correspodning dots.
    * Keys on the 'home row' correspond to the keys on a Perkins-style keyboard.
    * Note that the mapping below is arranged like the dots in a braille cell.
    * Only 6 dot input is supported.
    * @private
-   * @const {Object.<string, string>}
+   * @const {Object.<string, number>}
    */
   CODE_TO_DOT_: {'KeyF': 0x01, 'KeyJ': 0x08,
                  'KeyD': 0x02, 'KeyK': 0x10,
-                 'KeyS': 0x04, 'KeyL': 0x20 },
+                 'KeyS': 0x04, 'KeyL': 0x20,
+                 'Space': 0x100 },
 
   /**
    * The current engine ID as set by {@code onActivate}, or the empty string if
    * the IME is not active.
    * @type {string}
    * @private
    */
   engineID_: '',
 
   /**
@@ skipping 83 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.
    * @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.code, event.type);
+    return this.processKey_(event);
   },
 
   /**
    * 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 30 matching lines @@
   log_: function(func, message) {
     if (func === 'onKeyEvent') {
       return;
     }
     if (this.DEBUG) {
       console.log('BrailleIme.' + func + ': ' + message);
     }
   },
 
   /**
-   * Handles a querty key on the home row as a braille key.
-   * @param {string} code Key code.
-   * @param {string} type Type of key event.
+   * 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.
    * @private
    */
-  processKey_: function(code, type) {
+  processKey_: function(event) {
     if (!this.useStandardKeyboard_) {
       return false;
     }
-    var dot = this.CODE_TO_DOT_[code];
-    if (!dot) {
+    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 (type === 'keydown') {
+    if (event.type === 'keydown') {
       this.pressed_ |= dot;
       this.accumulated_ |= this.pressed_;
       return true;
-    } else if (type == 'keyup') {
+    } else if (event.type === 'keyup') {
       this.pressed_ &= ~dot;
-      if (this.pressed_ == 0 && this.accumulated_ != 0) {
-        this.sendToChromeVox_({type: 'brailleDots', dots: this.accumulated_});
+      if (this.pressed_ === 0 && this.accumulated_ !== 0) {
+        var dotsToSend = this.accumulated_;
         this.accumulated_ = 0;
+        if (dotsToSend & this.SPACE) {
+          // Space is sent as a blank cell.
+          dotsToSend &= ~this.SPACE;

[David Tseng, 2014/05/07 23:38:01]

Would it be clearer to just say
dotsToSend != this.SPACE?

+          if (dotsToSend != 0) {
+            // Can't combine space and actual dot keys.
+            return true;
+          }
+        }
+        this.sendToChromeVox_({type: 'brailleDots', dots: dotsToSend});
       }
       return true;
     }
     return false;
   },
 
   /**
    * Connects to the ChromeVox extension for message passing.
    * @private
    */
@@ skipping 114 matching lines @@
              label: 'Use standard keyboard for braille',
              style: 'check',
              visible: true,
              checked: this.useStandardKeyboard_,
              enabled: true
              }
          ]
         });
   }
 };