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

native_client_sdk/src/tests/nacl_io_test/tty_test.cc

 // Copyright 2013 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 <string.h>
 #include <sys/ioctl.h>
 #include <sys/select.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <string>
 
 #include "dev_fs_for_testing.h"
 #include "gtest/gtest.h"
 #include "nacl_io/devfs/dev_fs.h"
 #include "nacl_io/filesystem.h"
 #include "nacl_io/ioctl.h"
 #include "nacl_io/kernel_intercept.h"
 #include "nacl_io/kernel_proxy.h"
 #include "nacl_io/osdirent.h"
 
 using namespace nacl_io;
 
 namespace {
 
+static int ki_ioctl_wrapper(int fd, int request, ...) {
+  va_list ap;
+  va_start(ap, request);
+  int rtn = ki_ioctl(fd, request, ap);
+  va_end(ap);
+  return rtn;
+}
+
 class TtyNodeTest : public ::testing::Test {
  public:
-  TtyNodeTest() : fs_(&pepper_) {}
+  TtyNodeTest() : fs_(&ppapi_) {}
 
   void SetUp() {
     ASSERT_EQ(0, fs_.Access(Path("/tty"), R_OK | W_OK));
     ASSERT_EQ(EACCES, fs_.Access(Path("/tty"), X_OK));
     ASSERT_EQ(0, fs_.Open(Path("/tty"), O_RDWR, &dev_tty_));
     ASSERT_NE(NULL_NODE, dev_tty_.get());
   }
 
  protected:
-  FakePepperInterface pepper_;
+  FakePepperInterface ppapi_;
   DevFsForTesting fs_;
   ScopedNode dev_tty_;
 };
 
 class TtyTest : public ::testing::Test {
  public:
   void SetUp() {
     ASSERT_EQ(0, ki_push_state_for_testing());
-    ASSERT_EQ(0, ki_init(&kp_));
+    ASSERT_EQ(0, ki_init_interface(&kp_, &ppapi_));
+
+    buffer_iface_ = ppapi_.GetVarArrayBufferInterface();
+    var_iface_ = ppapi_.GetVarInterface();
   }
 
   void TearDown() {
     ki_uninit();
   }
 
+  int TtyWrite(int fd, const char* string) {
+    size_t len = strlen(string);
+    PP_Var message_var = buffer_iface_->Create(strlen(string));
+
+    char* data = static_cast<char*>(buffer_iface_->Map(message_var));
+    EXPECT_NE((char*)NULL, data);
+
+    memcpy(data, string, len);
+    buffer_iface_->Unmap(message_var);
+
+    int result = ki_ioctl_wrapper(fd, NACL_IOC_HANDLEMESSAGE, &message_var);
+
+    var_iface_->Release(message_var);
+    return result;
+  }
+
  protected:
+  FakePepperInterface ppapi_;
   KernelProxy kp_;
+  VarArrayBufferInterface* buffer_iface_;
+  VarInterface* var_iface_;
 };
 
 TEST_F(TtyNodeTest, InvalidIoctl) {
   // 123 is not a valid ioctl request.
   EXPECT_EQ(EINVAL, dev_tty_->Ioctl(123));
 }
 
 TEST_F(TtyNodeTest, TtyInput) {
   // Now let's try sending some data over.
   // First we create the message.
   std::string message("hello, how are you?\n");
-  struct tioc_nacl_input_string packaged_message;
-  packaged_message.length = message.size();
-  packaged_message.buffer = message.data();
+  VarArrayBufferInterface* buffer_iface = ppapi_.GetVarArrayBufferInterface();
+  VarInterface* var_iface = ppapi_.GetVarInterface();
+  PP_Var message_var = buffer_iface->Create(message.size());
+
+  char* data = static_cast<char*>(buffer_iface->Map(message_var));
+  ASSERT_NE((char*)NULL, data);
+
+  memcpy(data, message.data(), message.size());
+  buffer_iface->Unmap(message_var);
 
   // Now we make buffer we'll read into.
   // We fill the buffer and a backup buffer with arbitrary data
   // and compare them after reading to make sure read doesn't
   // clobber parts of the buffer it shouldn't.
   int bytes_read;
   char buffer[100];
   char backup_buffer[100];
   memset(buffer, 'a', 100);
   memset(backup_buffer, 'a', 100);
 
   // Now we actually send the data
-  EXPECT_EQ(0, dev_tty_->Ioctl(TIOCNACLINPUT, &packaged_message));
+  EXPECT_EQ(0, dev_tty_->Ioctl(NACL_IOC_HANDLEMESSAGE, &message_var));
+
+  var_iface->Release(message_var);
 
   // We read a small chunk first to ensure it doesn't give us
   // more than we ask for.
   HandleAttr attrs;
   EXPECT_EQ(0, dev_tty_->Read(attrs, buffer, 5, &bytes_read));
   EXPECT_EQ(5, bytes_read);
   EXPECT_EQ(0, memcmp(message.data(), buffer, 5));
   EXPECT_EQ(0, memcmp(buffer + 5, backup_buffer + 5, 95));
 
   // Now we ask for more data than is left in the tty, to ensure
@@ skipping 36 matching lines @@
   handler.user_data = &user_data;
 
   EXPECT_EQ(0, dev_tty_->Ioctl(TIOCNACLOUTPUT, &handler));
 
   EXPECT_EQ(0, dev_tty_->Write(attrs, message, message_len, &bytes_written));
   EXPECT_EQ(message_len, bytes_written);
   EXPECT_EQ(message_len, user_data.output_count);
   EXPECT_EQ(0, strncmp(user_data.output_buf, message, message_len));
 }
 
-static int ki_ioctl_wrapper(int fd, int request, ...) {
-  va_list ap;
-  va_start(ap, request);
-  int rtn = ki_ioctl(fd, request, ap);
-  va_end(ap);
-  return rtn;
-}
-
-static int TtyWrite(int fd, const char* string) {
-  struct tioc_nacl_input_string input;
-  input.buffer = string;
-  input.length = strlen(input.buffer);
-  return ki_ioctl_wrapper(fd, TIOCNACLINPUT, &input);
-}
-
 // Returns:
 //   0 -> Not readable
 //   1 -> Readable
 //  -1 -> Error occured
 static int IsReadable(int fd) {
   struct timeval timeout = {0, 0};
   fd_set readfds;
   fd_set errorfds;
   FD_ZERO(&readfds);
   FD_ZERO(&errorfds);
   FD_SET(fd, &readfds);
   FD_SET(fd, &errorfds);
   int rtn = ki_select(fd + 1, &readfds, NULL, &errorfds, &timeout);
   if (rtn == 0)
     return 0;  // not readable
   if (rtn != 1)
     return -1;  // error
   if (FD_ISSET(fd, &errorfds))
     return -2;  // error
   if (!FD_ISSET(fd, &readfds))
     return -3;  // error
   return 1;     // readable
 }
 
+TEST_F(TtyTest, Empty) {
+}

[Sam Clegg, 2014/06/17 22:29:29]

?

[binji, 2014/06/17 22:55:23]

Done.

+
 TEST_F(TtyTest, TtySelect) {
   struct timeval timeout;
   fd_set readfds;
   fd_set writefds;
   fd_set errorfds;
 
   int tty_fd = ki_open("/dev/tty", O_RDONLY);
   ASSERT_GT(tty_fd, 0) << "tty open failed: " << errno;
 
   FD_ZERO(&readfds);
@@ skipping 141 matching lines @@
   pthread_join(resize_thread, NULL);
   ASSERT_EQ(-1, rtn);
   ASSERT_EQ(EINTR, errno);
   ASSERT_EQ(0, IsReadable(tty_fd));
 }
 
 /*
  * Sleep for 50ms then send some input to the /dev/tty.
  */
 static void* input_thread_main(void* arg) {
+  TtyTest* thiz = static_cast<TtyTest*>(arg);
+
   usleep(50 * 1000);
 
   int fd = ki_open("/dev/tty", O_RDONLY);
-  TtyWrite(fd, "test\n");
+  thiz->TtyWrite(fd, "test\n");
   return NULL;
 }
 
 TEST_F(TtyTest, InputDuringSelect) {
   // Test that input which occurs while in select causes
   // select to return.
   int tty_fd = ki_open("/dev/tty", O_RDONLY);
 
   fd_set readfds;
   fd_set errorfds;
   FD_ZERO(&readfds);
   FD_ZERO(&errorfds);
   FD_SET(tty_fd, &readfds);
   FD_SET(tty_fd, &errorfds);
 
   pthread_t resize_thread;
-  pthread_create(&resize_thread, NULL, input_thread_main, NULL);
+  pthread_create(&resize_thread, NULL, input_thread_main, this);
 
   struct timeval timeout;
   timeout.tv_sec = 20;
   timeout.tv_usec = 0;
 
   int rtn = ki_select(tty_fd + 1, &readfds, NULL, &errorfds, &timeout);
   pthread_join(resize_thread, NULL);
 
   ASSERT_EQ(1, rtn);
 }
-}
+
+}  // namespace