Make contracted braille input work in more contexts.

chrome/browser/resources/chromeos/chromevox/braille/braille_input_handler_test.unitjs

 // 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.
 
 // Include test fixture.
 GEN_INCLUDE(['../testing/chromevox_unittest_base.js']);
 
 GEN_INCLUDE(['../testing/fake_objects.js']);
 
 // Fake out the Chrome API namespace we depend on.
@@ skipping 20 matching lines @@
   /** @private {string} */
   this.text_ = '';
   /** @private {number} */
   this.selectionStart_ = 0;
   /** @private {number} */
   this.selectionEnd_ = 0;
   /** @private {number} */
   this.contextID_ = 0;
   /** @private {boolean} */
   this.allowDeletes_ = false;
+  /** @private {string} */
+  this.uncommittedText_ = '';
+  /** @private {?Array<number>} */
+  this.extraCells_ = [];
   port.postMessage = goog.bind(this.handleMessage_, this);
 }
 
 
 /**
  * Sets the content and selection (or cursor) of the edit field.
  * This fakes what happens when the field is edited by other means than
  * via the braille keyboard.
  * @param {string} text Text to replace the current content of the field.
  * @param {number} selectionStart Start of the selection or cursor position.
@@ skipping 76 matching lines @@
     text, selectionStart, opt_selectionEnd) {
   var selectionEnd = goog.isDef(opt_selectionEnd) ? opt_selectionEnd :
       selectionStart;
   assertEquals(text, this.text_);
   assertEquals(selectionStart, this.selectionStart_);
   assertEquals(selectionEnd, this.selectionEnd_);
 };
 
 
 /**
+ * Asserts that the uncommitted text last sent to the IME is the given text.
+ * @param {string} text
+ */
+FakeEditor.prototype.assertUncommittedTextIs = function(text) {
+  assertEquals(text, this.uncommittedText_);
+};
+
+
+/**
+ * Asserts that the input handler has added 'extra cells' for uncommitted
+ * text into the braille content.
+ * @param {string} cells Cells as a space-separated list of numbers.
+ */
+FakeEditor.prototype.assertExtraCellsAre = function(cells) {
+  assertEqualsJSON(cellsToArray(cells), this.extraCells_);
+};
+
+
+/**
  * Sends a message from the IME to the input handler.
  * @param {Object} msg The message to send.
  * @private
  */
 FakeEditor.prototype.message_ = function(msg) {
   var listener = this.port_.onMessage.getListener();
   assertNotEquals(null, listener);
   listener(msg);
 };
 
 
 /**
  * Calls the {@code onDisplayContentChanged} method of the input handler
  * with the current editor content and selection.
  * @private
  */
 FakeEditor.prototype.callOnDisplayContentChanged_ = function() {
-  this.inputHandler_.onDisplayContentChanged(
-      cvox.BrailleUtil.createValue(
-          this.text_, this.selectionStart_, this.selectionEnd_));
+  var content = cvox.BrailleUtil.createValue(
+      this.text_, this.selectionStart_, this.selectionEnd_)
+  var grabExtraCells = function() {
+    var span = content.getSpanInstanceOf(cvox.ExtraCellsSpan);
+    assertNotEquals(null, span);
+    // Convert the ArrayBuffer to a normal array for easier comparision.
+    this.extraCells_ = Array.prototype.map.call(new Uint8Array(span.cells),
+                                                function(a) {return a;});
+  }.bind(this);
+  this.inputHandler_.onDisplayContentChanged(content, grabExtraCells);
+  grabExtraCells();
 };
 
 
 /**
  * Informs the input handler that a new text field is focused.  The content
  * of the field is not cleared and should be updated separately.
  * @param {string} fieldType The type of the field (see the documentation
  *     for the {@code chrome.input.ime} API).
  */
 FakeEditor.prototype.focus = function(fieldType) {
@@ skipping 12 matching lines @@
   this.contextID_ = 0;
 };
 
 
 /**
  * Handles a message from the input handler to the IME.
  * @param {Object} msg The message.
  * @private
  */
 FakeEditor.prototype.handleMessage_ = function(msg) {
-  assertEquals('replaceText', msg.type);
   assertEquals(this.contextID_, msg.contextID);
-  var deleteBefore = msg.deleteBefore;
-  var newText = msg.newText;
-  assertTrue(goog.isNumber(deleteBefore));
-  assertTrue(goog.isString(newText));
-  assertTrue(deleteBefore <= this.selectionStart_);
-  if (deleteBefore > 0) {
-    assertTrue(this.allowDeletes_);
-    this.text_ =
-        this.text_.substring(0, this.selectionStart_ - deleteBefore) +
-        this.text_.substring(this.selectionEnd_);
-    this.selectionStart_ -= deleteBefore;
-    this.selectionEnd_ = this.selectionStart_;
-    this.callOnDisplayContentChanged_();
+  switch(msg.type) {
+    case 'replaceText':
+      var deleteBefore = msg.deleteBefore;
+      var newText = msg.newText;
+      assertTrue(goog.isNumber(deleteBefore));
+      assertTrue(goog.isString(newText));
+      assertTrue(deleteBefore <= this.selectionStart_);
+      if (deleteBefore > 0) {
+        assertTrue(this.allowDeletes_);
+        this.text_ =
+            this.text_.substring(0, this.selectionStart_ - deleteBefore) +
+            this.text_.substring(this.selectionEnd_);
+        this.selectionStart_ -= deleteBefore;
+        this.selectionEnd_ = this.selectionStart_;
+        this.callOnDisplayContentChanged_();
+      }
+      this.insert(newText);
+      break;
+    case 'setUncommitted':
+      assertTrue(goog.isString(msg.text));
+      this.uncommittedText_ = msg.text;
+      break;
+    case 'commitUncommitted':
+      this.insert(this.uncommittedText_);
+      this.uncommittedText_ = '';
+      break;
+    default:
+      throw new Error('Unexpected message to IME: ' + JSON.stringify(msg));
   }
-  this.insert(newText);
 };
 
 /*
  * Fakes a {@code Port} used for message passing in the Chrome extension APIs.
  * @constructor
  */
 function FakePort() {
   /** @type {FakeChromeEvent} */
   this.onDisconnect = new FakeChromeEvent();
   /** @type {FakeChromeEvent} */
@@ skipping 139 matching lines @@
 /**
  * Converts a list of cells, represented as a string, to an array.
  * @param {string} cells A string with space separated groups of digits.
  *     Each group corresponds to one braille cell and each digit in a group
  *     corresponds to a particular dot in the cell (1 to 8).  As a special
  *     case, the digit 0 by itself represents a blank cell.
  * @return {Array.<number>} An array with each cell encoded as a bit
  *     pattern (dot 1 uses bit 0, etc).
  */
 function cellsToArray(cells) {
+  if (!cells)
+    return [];
   return cells.split(/\s+/).map(function(cellString) {
     var cell = 0;
     assertTrue(cellString.length > 0);
     if (cellString != '0') {
       for (var i = 0; i < cellString.length; ++i) {
         var dot = cellString.charCodeAt(i) - '0'.charCodeAt(0);
         assertTrue(dot >= 1);
         assertTrue(dot <= 8);
         cell |= 1 << (dot - 1);
       }
@@ skipping 150 matching lines @@
 
   editor.blur();
   editor.setActive(false);
 });
 
 
 TEST_F('CvoxBrailleInputHandlerUnitTest', 'InputContracted', function() {
   var editor = this.createEditor();
   this.translatorManager.setTranslators(this.contractedTranslator,
                                         this.uncontractedTranslator);
+  editor.setContent('', 0);
   editor.setActive(true);
   editor.focus('text');
   this.assertExpandingSelection();
 
   // First, type a 'b'.
   assertTrue(this.sendCells('12'));
+  editor.assertContentIs('', 0);
   // Remember that the contracted translator produces uppercase.
-  editor.assertContentIs('BUT', 'BUT'.length);
+  editor.assertUncommittedTextIs('BUT');
+  editor.assertExtraCellsAre('12');
   this.assertExpandingNone();
 
-  // From here on, the input handler needs to replace already entered text.
-  editor.setAllowDeletes(true);
   // Typing 'rl' changes to a different contraction.
   assertTrue(this.sendCells('1235 123'));
-  editor.assertContentIs('BRAILLE', 'BRAILLE'.length);
+  editor.assertUncommittedTextIs('BRAILLE');
+  editor.assertContentIs('', 0);
+  editor.assertExtraCellsAre('12 1235 123');
+  this.assertExpandingNone();
+
   // Now, finish the word.
   assertTrue(this.sendCells('0'));
   editor.assertContentIs('BRAILLE ', 'BRAILLE '.length);
-  this.assertExpandingNone();
+  editor.assertUncommittedTextIs('');
+  editor.assertExtraCellsAre('');
+  this.assertExpandingSelection();
 
   // Move the cursor to the beginning.
   editor.select(0);
   this.assertExpandingSelection();
 
   // Typing now uses the uncontracted table.
   assertTrue(this.sendCells('12'));  // 'b'
   editor.assertContentIs('bBRAILLE ', 1);
   this.assertExpandingSelection();
   editor.select('bBRAILLE'.length);
   this.assertExpandingSelection();
   assertTrue(this.sendCells('12')); // 'b'
   editor.assertContentIs('bBRAILLEb ', 'bBRAILLEb'.length);
   // Move to the end, where contracted typing should work.
   editor.select('bBRAILLEb '.length);
   assertTrue(this.sendCells('1456 0'));  // Symbol for 'this', then space.
-  this.assertExpandingNone();
-  editor.assertContentIs('bBRAILLEb THIS ', 'bBRAILLEb this '.length);
+  this.assertExpandingSelection();
+  editor.assertContentIs('bBRAILLEb THIS ', 'bBRAILLEb THIS '.length);
 
-  // Move between the two words.
+  // Move to between the two words.
   editor.select('bBRAILLEb'.length);
   this.assertExpandingSelection();
-  assertTrue(this.sendCells('0'));
-  assertTrue(this.sendCells('12'));  // 'b' for 'but'
-  editor.assertContentIs('bBRAILLEb BUT THIS ', 'bBRAILLEb BUT'.length);
+  assertTrue(this.sendCells('0 12'));  // Space plus 'b' for 'but'
+  editor.assertUncommittedTextIs('BUT');
+  editor.assertExtraCellsAre('12');
+  editor.assertContentIs('bBRAILLEb  THIS ', 'bBRAILLEb '.length);
   this.assertExpandingNone();
 });
 
 
 TEST_F('CvoxBrailleInputHandlerUnitTest', 'TypingUrlWithContracted',
        function() {
   var editor = this.createEditor();
   this.translatorManager.setTranslators(this.contractedTranslator,
                                         this.uncontractedTranslator);
   editor.setActive(true);
@@ skipping 18 matching lines @@
 TEST_F('CvoxBrailleInputHandlerUnitTest', 'Backspace', function() {
   var editor = this.createEditor();
   this.translatorManager.setTranslators(this.contractedTranslator,
                                         this.uncontractedTranslator);
   editor.setActive(true);
   editor.focus('text');
 
   // Add some text that we can delete later.
   editor.setContent('Text ', 'Text '.length);
 
-  // The IME needs to delete text, even when typing.
-  editor.setAllowDeletes(true);
   // Type 'brl' to make sure replacement works when deleting text.
   assertTrue(this.sendCells('12 1235 123'));
-  editor.assertContentIs('Text BRAILLE', 'Text BRAILLE'.length);
+  editor.assertUncommittedTextIs('BRAILLE');
 
   // Delete what we just typed, one cell at a time.
   this.sendKeyEvent('Backspace');
-  editor.assertContentIs('Text BR', 'Text BR'.length);
+  editor.assertUncommittedTextIs('BR');
   this.sendKeyEvent('Backspace');
-  editor.assertContentIs('Text BUT', 'Text BUT'.length);
+  editor.assertUncommittedTextIs('BUT');
   this.sendKeyEvent('Backspace');
-  editor.assertContentIs('Text ', 'Text '.length);
+  editor.assertUncommittedTextIs('');
 
   // Now, backspace should be handled as usual, synthetizing key events.
   assertEquals(0, this.keyEvents.length);
   this.sendKeyEvent('Backspace');
   assertEqualsJSON([{keyCode: 8, keyName: 'Backspace', charValue: 8}],
                    this.keyEvents);
 });
 
 
 TEST_F('CvoxBrailleInputHandlerUnitTest', 'KeysImeNotActive', function() {
   var editor = this.createEditor();
   this.sendKeyEvent('Enter');
   this.sendKeyEvent('ArrowUp');
   assertEqualsJSON([{keyCode: 13, keyName: 'Enter', charValue: 0x0A},
                     {keyCode: 38, keyName: 'ArrowUp', charValue: 0x41}],
                    this.keyEvents);
 });