[NaCl SDK] Remove use of TIOCNACLINPUT from nacl_io/ppapi_simple.

native_client_sdk/src/libraries/ppapi_simple/ps_instance.cc

 // Copyright (c) 2012 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 <errno.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/ioctl.h>
@@ skipping 272 matching lines @@
       Error("Failed to open /dev/tty.\n");
     }
   }
 
   RegisterMessageHandler("jspipe1", MessageHandlerInputStatic, this);
   RegisterMessageHandler("jspipe2", MessageHandlerInputStatic, this);
   RegisterMessageHandler("jspipe3", MessageHandlerInputStatic, this);
 
   exit_message_ = getenv("PS_EXIT_MESSAGE");
 
-  // If PS_EXIT_MESSAGE is set in the envionment then we perform a handshake
+  // If PS_EXIT_MESSAGE is set in the environment then we perform a handshake
   // with JavaScript when program exits.
   if (exit_message_ != NULL)
     nacl_io_register_exit_handler(HandleExitStatic, this);
 
   // Set line buffering on stdout and stderr
 #if !defined(WIN32)
   setvbuf(stderr, NULL, _IOLBF, 0);
   setvbuf(stdout, NULL, _IOLBF, 0);
 #endif
   return true;
@@ skipping 98 matching lines @@
   assert(message.is_string());
   pthread_mutex_lock(&exit_lock_);
   pthread_cond_signal(&exit_cond_);
   pthread_mutex_unlock(&exit_lock_);
 }
 
 void PSInstance::MessageHandlerInput(const pp::Var& key,
                                      const pp::Var& message) {
   std::string key_string = key.AsString();
 
-  if (message.is_string() && key_string == tty_prefix_) {
-    std::string buffer = message.AsString();
-
-    // Since our message may contain null characters, we can't send it as a
-    // naked C string, so we package it up in this struct before sending it
-    // to the ioctl.
-    struct tioc_nacl_input_string ioctl_message;
-    ioctl_message.length = buffer.size();
-    ioctl_message.buffer = buffer.c_str();
-    int ret = ioctl(tty_fd_, TIOCNACLINPUT, &ioctl_message);
-    if (ret != 0 && errno != ENOTTY) {
-      Error("ioctl returned unexpected error: %d.\n", ret);
-    }
-    return;
-  }
-
   if (!message.is_array_buffer()) {
     Error("Expected ArrayBuffer object but got: %d", message.pp_var().type);
     return;
   }
 
   const char* filename = NULL;
   if (key_string == tty_prefix_) {
     filename = "/dev/tty";
   } else if (key_string == "jspipe1") {
     filename = "/dev/jspipe1";
   } else if (key_string == "jspipe2") {
     filename = "/dev/jspipe2";
   } else if (key_string == "jspipe3") {
     filename = "/dev/jspipe3";
   } else {
     Error("unexpected input key: %s", key_string.c_str());
     return;
   }
 
   int fd = open(filename, O_RDONLY);
   if (fd < 0) {
     Error("error opening file: %s (%s)", filename, strerror(errno));
     return;
   }
 
   int ret = ioctl(fd, NACL_IOC_HANDLEMESSAGE, &message.pp_var());
   if (ret != 0) {
     Error("ioctl on %s failed: %d.\n", filename, ret);
+    close(fd);
     return;
   }
+
+  close(fd);
 }
 
 void PSInstance::HandleExitStatic(int status, void* user_data) {
-  PSInstance* instance = reinterpret_cast<PSInstance*>(user_data);
+  PSInstance* instance = static_cast<PSInstance*>(user_data);
   instance->ExitHandshake(status);
 }
 
 void PSInstance::HandleResize(int width, int height) {
   struct winsize size;
   memset(&size, 0, sizeof(size));
   size.ws_col = width;
   size.ws_row = height;
   ioctl(tty_fd_, TIOCSWINSZ, &size);
 }
 
 void PSInstance::MessageHandlerResize(const pp::Var& message) {
   assert(message.is_array());
   pp::VarArray array(message);
   assert(array.GetLength() == 2);
 
   int width = array.Get(0).AsInt();
   int height = array.Get(1).AsInt();
   HandleResize(width, height);
 }
 
 ssize_t PSInstance::TtyOutputHandlerStatic(const char* buf,
                                            size_t count,
                                            void* user_data) {
-  PSInstance* instance = reinterpret_cast<PSInstance*>(user_data);
+  PSInstance* instance = static_cast<PSInstance*>(user_data);
   return instance->TtyOutputHandler(buf, count);
 }
 
 void PSInstance::MessageHandlerExitStatic(const pp::Var& key,
                                           const pp::Var& value,
                                           void* user_data) {
-  PSInstance* instance = reinterpret_cast<PSInstance*>(user_data);
+  PSInstance* instance = static_cast<PSInstance*>(user_data);
   instance->MessageHandlerExit(value);
 }
 
 void PSInstance::MessageHandlerInputStatic(const pp::Var& key,
                                            const pp::Var& value,
                                            void* user_data) {
-  PSInstance* instance = reinterpret_cast<PSInstance*>(user_data);
+  PSInstance* instance = static_cast<PSInstance*>(user_data);
   instance->MessageHandlerInput(key, value);
 }
 
 void PSInstance::MessageHandlerResizeStatic(const pp::Var& key,
                                             const pp::Var& value,
                                             void* user_data) {
-  PSInstance* instance = reinterpret_cast<PSInstance*>(user_data);
+  PSInstance* instance = static_cast<PSInstance*>(user_data);
   instance->MessageHandlerResize(value);
 }
 
 void PSInstance::RegisterMessageHandler(std::string message_name,
                                         MessageHandler_t handler,
                                         void* user_data) {
   Trace("registering msg handler: %s", message_name.c_str());
   if (handler == NULL) {
     message_handlers_.erase(message_name);
     return;
   }
 
   MessageHandler message_handler = { handler, user_data };
   message_handlers_[message_name] = message_handler;
 }
 
 void PSInstance::PostEvent(PSEventType type, const PP_Var& var) {
   assert(PSE_INSTANCE_HANDLEMESSAGE == type);
 
   pp::Var event(var);
-  // Legacy support for passing TTY input as a string <prefix>:<payload>
-  // TODO(sbc): remove this in a future release.
-  if (tty_fd_ >= 0 && event.is_string()) {
-    std::string message = event.AsString();
-    size_t prefix_len = strlen(tty_prefix_);
-    if (message.size() > prefix_len) {
-      if (!strncmp(message.c_str(), tty_prefix_, prefix_len)) {
-        LOG_WARN("Passing TTY data using a string prefix is deprecated. "
-                 "Use a JavaScript dictionary instead.");
-        MessageHandlerInput(pp::Var(message.substr(0, prefix_len)),
-                            pp::Var(message.substr(prefix_len)));
-        return;
-      }
-    }
-  }
 
   // If the message is a dictionary then see if it matches one
   // of the specific handlers, then call that handler rather than
   // queuing an event.
   if (event.is_dictionary()) {
     pp::VarDictionary dictionary(var);
     pp::VarArray keys = dictionary.GetKeys();
     if (keys.GetLength() == 1) {
       pp::Var key = keys.Get(0);
       Trace("calling handler for: %s", key.AsString().c_str());
-      MessageHandlerMap::iterator iter =
-          message_handlers_.find(key.AsString());
+      MessageHandlerMap::iterator iter = message_handlers_.find(key.AsString());
       if (iter != message_handlers_.end()) {
         MessageHandler_t handler = iter->second.handler;
         void* user_data = iter->second.user_data;
         handler(key, dictionary.Get(key), user_data);
         return;
       }
     }
   }
 
   PSInterfaceVar()->AddRef(var);
@@ skipping 72 matching lines @@
 
 void PSInstance::Graphics3DContextLost() {
   Log("Graphics3DContextLost\n");
   PostEvent(PSE_GRAPHICS3D_GRAPHICS3DCONTEXTLOST);
 }
 
 void PSInstance::MouseLockLost() {
   Log("MouseLockLost\n");
   PostEvent(PSE_MOUSELOCK_MOUSELOCKLOST);
 }