Allow braille translation result to be larger than twice the size of the input.

The liblouis wrapper used to allocate an output buffer that was twice as big
as the number of input characters.  There are situations where this is
not enough.  The new approach is to retry with a larger buffer up to
a certain limit.

R=dtseng@chromium.org
BUG=none

Review URL: https://codereview.chromium.org/124403002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@243251 0039d316-1c4b-4281-b951-d872f2087c98

chrome/test/data/chromeos/liblouis_nacl/test.js

@@ -42,7 +42,7 @@ function rpc(command, args, callback) {
   var messageId = '' + nextMessageId++;
   args['command'] = command;
   args['message_id'] = messageId;
-  var json = JSON.stringify(args)
+  var json = JSON.stringify(args);
   console.log('Message to liblouis: ' + json);
   naclEmbed.postMessage(json);
   pendingCallback = callback;
@@ -76,6 +76,17 @@ loadLibrary(function() {
         })));
   },
 
+  // Regression test for the case where the translated result is more than
+  // the double size of the input.  In this particular case, a single capital
+  // letter 'T' should be translated to 3 cells in US English grade 2
+  // braille (dots 56, 6, 2345).
+  function testTranslateGrade2SingleCapital() {
+    rpc('Translate', { 'table_name': 'en-us-g2.ctb', 'text': 'T'},
+        pass(expectSuccessReply(function(reply) {
+          chrome.test.assertEq('30201e', reply['cells']);
+        })));
+  },
+
   function testBackTranslateString() {
     rpc('BackTranslate', { 'table_name': TABLE_NAME, 'cells': CELLS},
         pass(expectSuccessReply(function(reply) {

third_party/liblouis/nacl_wrapper/liblouis_wrapper.cc

@@ -121,12 +121,13 @@ bool LibLouisWrapper::Translate(const TranslationParams& params,
     // TODO(jbroman): log this
     return false;
   }
+  // To avoid unsigned/signed comparison warnings.
+  int inbufsize = inbuf.size();
 
-  int inlen = inbuf.size();
-  int outlen = inlen * 2;  // TODO(jbroman): choose this size more accurately.
-  std::vector<widechar> outbuf(outlen);
-  std::vector<int> text_to_braille(inlen);
-  std::vector<int> braille_to_text(outlen);
+  std::vector<widechar> outbuf;
+  std::vector<int> text_to_braille(inbuf.size());
+  std::vector<int> braille_to_text;
+  int outlen;
 
   // Compute the cursor position pointer to pass to liblouis.
   int out_cursor_position;
@@ -139,15 +140,36 @@ bool LibLouisWrapper::Translate(const TranslationParams& params,
     out_cursor_position_ptr = &out_cursor_position;
   }
 
-  // Invoke liblouis.
-  int result = lou_translate(params.table_name.c_str(),
-      &inbuf[0], &inlen, &outbuf[0], &outlen,
-      NULL /* typeform */, NULL /* spacing */,
-      &text_to_braille[0], &braille_to_text[0],
-      out_cursor_position_ptr, dotsIO /* mode */);
-  if (result == 0) {
-    // TODO(jbroman): log this
-    return false;
+  // Invoke liblouis.  Do this in a loop since we can't precalculate the
+  // translated size.  We add an extra slot in the output buffer so that
+  // common cases like single digits or capital letters won't always trigger
+  // retranslations (see the comments above the second exit condition inside
+  // the loop).  We also set an arbitrary upper bound for the allocation
+  // to make sure the loop exits without running out of memory.
+  for (int outalloc = (inbufsize + 1) * 2, maxoutalloc = (inbufsize + 1) * 8;
+       outalloc <= maxoutalloc; outalloc *= 2) {
+    int inlen = inbufsize;
+    outlen = outalloc;
+    outbuf.resize(outalloc);
+    braille_to_text.resize(outalloc);
+    int result = lou_translate(params.table_name.c_str(),
+                               &inbuf[0], &inlen, &outbuf[0], &outlen,
+                               NULL /* typeform */, NULL /* spacing */,
+                               &text_to_braille[0], &braille_to_text[0],
+                               out_cursor_position_ptr, dotsIO /* mode */);
+    if (result == 0) {
+      // TODO(jbroman): log this
+      return false;
+    }
+    // If all of inbuf was not consumed, the output buffer must be too small
+    // and we have to retry with a larger buffer.
+    // In addition, if all of outbuf was exhausted, there's no way to know if
+    // more space was needed, so we'll have to retry the translation in that
+    // corner case as well.
+    if (inlen == inbufsize && outlen < outalloc)
+      break;
+    outbuf.clear();
+    braille_to_text.clear();
   }
 
   // Massage the result.