[NaCl SDK] nacl_io: Add flow control the JavaScript pipes.

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 {
 
+class TtyNodeTest : public ::testing::Test {
+ public:
+  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:
+  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, 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());
   }
 
-  void TearDown() { ki_uninit(); }
+  void TearDown() {
+    ki_uninit();
+  }
 
  protected:
   KernelProxy kp_;
-  DevFsForTesting fs_;
-  ScopedNode dev_tty_;
 };
 
-TEST_F(TtyTest, InvalidIoctl) {
+TEST_F(TtyNodeTest, InvalidIoctl) {
   // 123 is not a valid ioctl request.
   EXPECT_EQ(EINVAL, dev_tty_->Ioctl(123));
 }
 
-TEST_F(TtyTest, TtyInput) {
+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();
 
   // 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
@@ skipping 30 matching lines @@
   size_t output_count;
 };
 
 static ssize_t output_handler(const char* buf, size_t count, void* data) {
   user_data_t* user_data = static_cast<user_data_t*>(data);
   user_data->output_buf = buf;
   user_data->output_count = count;
   return count;
 }
 
-TEST_F(TtyTest, TtyOutput) {
+TEST_F(TtyNodeTest, TtyOutput) {
   // When no handler is registered then all writes should return EIO
   int bytes_written = 10;
   const char* message = "hello\n";
   int message_len = strlen(message);
   HandleAttr attrs;
   EXPECT_EQ(EIO, dev_tty_->Write(attrs, message, message_len, &bytes_written));
 
   // Setup output handler with user_data to record calls.
   user_data_t user_data;
   user_data.output_buf = NULL;
@@ skipping 125 matching lines @@
   ASSERT_EQ(0, IsReadable(tty_fd));
 }
 
 static int g_recieved_signal;
 
 static void sighandler(int sig) { g_recieved_signal = sig; }
 
 TEST_F(TtyTest, WindowSize) {
   // Get current window size
   struct winsize old_winsize = {0};
-  ASSERT_EQ(0, dev_tty_->Ioctl(TIOCGWINSZ, &old_winsize));
+  int tty_fd = ki_open("/dev/tty", O_RDONLY);
+  ASSERT_EQ(0, ki_ioctl_wrapper(tty_fd, TIOCGWINSZ, &old_winsize));
 
   // Install signal handler
   sighandler_t new_handler = sighandler;
   sighandler_t old_handler = ki_signal(SIGWINCH, new_handler);
   ASSERT_NE(SIG_ERR, old_handler) << "signal return error: " << errno;
 
   g_recieved_signal = 0;
 
   // Set a new windows size
   struct winsize winsize;
   winsize.ws_col = 100;
   winsize.ws_row = 200;
-  EXPECT_EQ(0, dev_tty_->Ioctl(TIOCSWINSZ, &winsize));
+  EXPECT_EQ(0, ki_ioctl_wrapper(tty_fd, TIOCSWINSZ, &winsize));
   EXPECT_EQ(SIGWINCH, g_recieved_signal);
 
   // Restore old signal handler
   EXPECT_EQ(new_handler, ki_signal(SIGWINCH, old_handler));
 
   // Verify new window size can be queried correctly.
   winsize.ws_col = 0;
   winsize.ws_row = 0;
-  EXPECT_EQ(0, dev_tty_->Ioctl(TIOCGWINSZ, &winsize));
+  EXPECT_EQ(0, ki_ioctl_wrapper(tty_fd, TIOCGWINSZ, &winsize));
   EXPECT_EQ(100, winsize.ws_col);
   EXPECT_EQ(200, winsize.ws_row);
 
   // Restore original windows size.
-  EXPECT_EQ(0, dev_tty_->Ioctl(TIOCSWINSZ, &old_winsize));
+  EXPECT_EQ(0, ki_ioctl_wrapper(tty_fd, TIOCSWINSZ, &old_winsize));
 }
 
 /*
  * Sleep for 50ms then send a resize event to /dev/tty.
  */
 static void* resize_thread_main(void* arg) {
   usleep(50 * 1000);
 
   int* tty_fd = static_cast<int*>(arg);
   struct winsize winsize;
@@ skipping 50 matching lines @@
   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, &dev_tty_);
+  pthread_create(&resize_thread, NULL, input_thread_main, NULL);
 
   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);
 }
 }