Make undefined Unicode characters show up in a nicer way in braille.

third_party/liblouis/nacl_wrapper/liblouis_instance.cc

 // Copyright 2013 Google Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
 // use this file except in compliance with the License. You may obtain a copy of
 // the License at
 //
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
@@ skipping 86 matching lines @@
 
 // Well-known strings used for configuration.
 static const char kTablesDirKey[] = "tablesdir";
 static const char kTablesDirDefault[] = "tables";
 
 // Well-known strings used in JSON messages.
 static const char kCommandKey[] = "command";
 static const char kMessageIdKey[] = "message_id";
 static const char kInReplyToKey[] = "in_reply_to";
 static const char kErrorKey[] = "error";
-static const char kTableNameKey[] = "table_name";
+static const char kTableNamesKey[] = "table_names";
 static const char kSuccessKey[] = "success";
 static const char kTextKey[] = "text";
 static const char kCellsKey[] = "cells";
 static const char kCursorPositionKey[] = "cursor_position";
 static const char kTextToBrailleKey[] = "text_to_braille";
 static const char kBrailleToTextKey[] = "braille_to_text";
 static const char kCheckTableCommand[] = "CheckTable";
 static const char kTranslateCommand[] = "Translate";
 static const char kBackTranslateCommand[] = "BackTranslate";
 
@@ skipping 83 matching lines @@
   Json::Value reply(Json::objectValue);
   reply[kErrorKey] = error_message;
   reply[kInReplyToKey] = in_reply_to;
   reply[kSuccessKey] = false;
   pp::Var var_reply(writer.write(reply));
   PostMessage(var_reply);
 }
 
 void LibLouisInstance::HandleCheckTable(const Json::Value& message,
     const std::string& message_id) {
-  Json::Value table_name = message[kTableNameKey];
-  if (!table_name.isString()) {
-    PostError("expected table_name to be a string", message_id);
+  Json::Value table_names = message[kTableNamesKey];
+  if (!table_names.isString()) {
+    PostError("expected table_names to be a string", message_id);
     return;
   }
   PostWorkToBackground(cc_factory_.NewCallback(
       &LibLouisInstance::CheckTableInBackground,
-      table_name.asString(), message_id));
+      table_names.asString(), message_id));
 }
 
 void LibLouisInstance::CheckTableInBackground(int32_t result,
-    const std::string& table_name, const std::string& message_id) {
+    const std::string& table_names, const std::string& message_id) {
   if (result != PP_OK) {
     PostError("failed to transfer call to background thread", message_id);
     return;
   }
-  bool success = liblouis_.CheckTable(table_name);
+  bool success = liblouis_.CheckTable(table_names);
   Json::Value reply(Json::objectValue);
   reply[kSuccessKey] = success;
   PostReply(reply, message_id);
 }
 
 void LibLouisInstance::HandleTranslate(const Json::Value& message,
     const std::string& message_id) {
-  Json::Value table_name = message[kTableNameKey];
+  Json::Value table_names = message[kTableNamesKey];
   Json::Value text = message[kTextKey];
   Json::Value cursor_position = message[kCursorPositionKey];
-  if (!table_name.isString()) {
-    PostError("expected table_name to be a string", message_id);
+  if (!table_names.isString()) {
+    PostError("expected table_names to be a string", message_id);
     return;
   } else if (!text.isString()) {
     PostError("expected text to be a string", message_id);
     return;
   } else if (!cursor_position.isNull() && !cursor_position.isIntegral()) {
     PostError("expected cursor_position to be null or integral", message_id);
     return;
   }
   TranslationParams params;
-  params.table_name = table_name.asString();
+  params.table_names = table_names.asString();
   params.text = text.asString();
   params.cursor_position = cursor_position.isIntegral() ?
       cursor_position.asInt() : -1;
   PostWorkToBackground(cc_factory_.NewCallback(
       &LibLouisInstance::TranslateInBackground,
       params, message_id));
 }
 
 void LibLouisInstance::TranslateInBackground(int32_t result,
     const TranslationParams& params, const std::string& message_id) {
@@ skipping 17 matching lines @@
     reply[kBrailleToTextKey] = braille_to_text;
     if (translation_result.cursor_position >= 0) {
       reply[kCursorPositionKey] = translation_result.cursor_position;
     }
   }
   PostReply(reply, message_id);
 }
 
 void LibLouisInstance::HandleBackTranslate(const Json::Value& message,
     const std::string& message_id) {
-  Json::Value table_name = message[kTableNameKey];
+  Json::Value table_names = message[kTableNamesKey];
   Json::Value cells = message[kCellsKey];
-  if (!table_name.isString()) {
-    PostError("expected table_name to be a string", message_id);
+  if (!table_names.isString()) {
+    PostError("expected table_names to be a string", message_id);
     return;
   } else if (!cells.isString()) {
     PostError("expected cells to be a string", message_id);
     return;
   }
   std::vector<unsigned char> cells_vector;
   if (!HexStringToBytes(cells.asString(), &cells_vector)) {
     PostError("expected cells to be a valid hexadecimal string", message_id);
     return;
   }
   PostWorkToBackground(cc_factory_.NewCallback(
       &LibLouisInstance::BackTranslateInBackground,
-      table_name.asString(), cells_vector, message_id));
+      table_names.asString(), cells_vector, message_id));
 }
 
 void LibLouisInstance::BackTranslateInBackground(int32_t result,
-    const std::string& table_name, const std::vector<unsigned char>& cells,
+    const std::string& table_names, const std::vector<unsigned char>& cells,
     const std::string& message_id) {
   if (result != PP_OK) {
     PostError("failed to transfer call to background thread", message_id);
     return;
   }
   std::string text;
-  bool success = liblouis_.BackTranslate(table_name, cells, &text);
+  bool success = liblouis_.BackTranslate(table_names, cells, &text);
   Json::Value reply(Json::objectValue);
   reply[kSuccessKey] = success;
   if (success) {
     reply[kTextKey] = text;
   }
   PostReply(reply, message_id);
 }
 
 }  // namespace liblouis_nacl