[NaCl SDK} Add EventListener and EventEmitter to support epoll.

native_client_sdk/src/libraries/nacl_io/kernel_wrap_glibc.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 <sys/types.h>  // Include something that will define __GLIBC__.
 
 // The entire file is wrapped in this #if. We do this so this .cc file can be
 // compiled, even on a non-glibc build.
 #if defined(__native_client__) && defined(__GLIBC__)
 
 #include "nacl_io/kernel_wrap.h"
 #include <alloca.h>
 #include <dirent.h>
 #include <errno.h>
 #include <irt.h>
 #include <irt_syscalls.h>
 #include <nacl_stat.h>
 #include <string.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
+#include <sys/time.h>
 #include "nacl_io/kernel_intercept.h"
 
 
 namespace {
 
 void stat_to_nacl_stat(const struct stat* buf, nacl_abi_stat* nacl_buf) {
   memset(nacl_buf, 0, sizeof(struct nacl_abi_stat));
   nacl_buf->nacl_abi_st_dev = buf->st_dev;
   nacl_buf->nacl_abi_st_ino = buf->st_ino;
   nacl_buf->nacl_abi_st_mode = buf->st_mode;
@@ skipping 99 matching lines @@
 }
 
 int chmod(const char* path, mode_t mode) NOTHROW {
   return ki_chmod(path, mode);
 }
 
 int WRAP(chdir) (const char* pathname) {
   return (ki_chdir(pathname)) ? errno : 0;
 }
 
-int chown(const char* path, uid_t owner, gid_t group) {
+int chown(const char* path, uid_t owner, gid_t group) NOTHROW {
   return ki_chown(path, owner, group);
 }
 
 int WRAP(close)(int fd) {
   return (ki_close(fd) < 0) ? errno : 0;
 }
 
 int WRAP(dup)(int fd, int* newfd) NOTHROW {
   *newfd = ki_dup(fd);
   return (*newfd < 0) ? errno : 0;
 }
 
 int WRAP(dup2)(int fd, int newfd) NOTHROW {
   return (ki_dup2(fd, newfd) < 0) ? errno : 0;
 }
 
-int fchown(int fd, uid_t owner, gid_t group) {
+int fchown(int fd, uid_t owner, gid_t group) NOTHROW {
   return ki_fchown(fd, owner, group);
 }
 
 int WRAP(fstat)(int fd, struct nacl_abi_stat *nacl_buf) {
   struct stat buf;
   memset(&buf, 0, sizeof(struct stat));
   int res = ki_fstat(fd, &buf);
   if (res < 0)
     return errno;
   stat_to_nacl_stat(&buf, nacl_buf);
@@ skipping 55 matching lines @@
 }
 
 int ioctl(int d, int request, char* argp) NOTHROW {
   return ki_ioctl(d, request, argp);
 }
 
 int isatty(int fd) NOTHROW {
   return ki_isatty(fd);
 }
 
-int lchown(const char* path, uid_t owner, gid_t group) {
+int lchown(const char* path, uid_t owner, gid_t group) NOTHROW {
   return ki_lchown(path, owner, group);
 }
 
 int link(const char* oldpath, const char* newpath) NOTHROW {
   return ki_link(oldpath, newpath);
 }
 
 int mkdir(const char* path, mode_t mode) NOTHROW {
   return ki_mkdir(path, mode);
 }
@@ skipping 172 matching lines @@
 }
 
 int _real_rmdir(const char* pathname) {
   return REAL(rmdir)(pathname);
 }
 
 int _real_write(int fd, const void *buf, size_t count, size_t *nwrote) {
   return REAL(write)(fd, buf, count, nwrote);
 }
 
+uint64_t usec_since_epoch() {
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  return tv.tv_usec + (tv.tv_sec * 1000000);
+}
 
 void kernel_wrap_init() {
   static bool wrapped = false;
 
   if (!wrapped) {
     wrapped = true;
     DO_WRAP(chdir);
     DO_WRAP(close);
     DO_WRAP(dup);
     DO_WRAP(dup2);
@@ skipping 11 matching lines @@
     DO_WRAP(munmap);
     DO_WRAP(open_resource);
   }
 }
 
 EXTERN_C_END
 
 
 #endif  // defined(__native_client__) && defined(__GLIBC__)