Remove usage of deprecated APIs from d8

src/d8-posix.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 170 matching lines @@
 
 
 // A utility class that takes the array of command arguments and puts then in an
 // array of new[]ed UTF-8 C strings.  Deallocates them again when it goes out of
 // scope.
 class ExecArgs {
  public:
   ExecArgs() {
     exec_args_[0] = NULL;
   }
-  bool Init(Handle<Value> arg0, Handle<Array> command_args) {
+  bool Init(Isolate* isolate, Handle<Value> arg0, Handle<Array> command_args) {
     String::Utf8Value prog(arg0);
     if (*prog == NULL) {
       const char* message =
           "os.system(): String conversion of program name failed";
-      ThrowException(String::New(message));
+      isolate->ThrowException(String::NewFromUtf8(isolate, message));
       return false;
     }
     int len = prog.length() + 3;
     char* c_arg = new char[len];
     snprintf(c_arg, len, "%s", *prog);
     exec_args_[0] = c_arg;
     int i = 1;
     for (unsigned j = 0; j < command_args->Length(); i++, j++) {
       Handle<Value> arg(command_args->Get(Integer::New(j)));
       String::Utf8Value utf8_arg(arg);
       if (*utf8_arg == NULL) {
         exec_args_[i] = NULL;  // Consistent state for destructor.
         const char* message =
             "os.system(): String conversion of argument failed.";
-        ThrowException(String::New(message));
+        isolate->ThrowException(String::NewFromUtf8(isolate, message));
         return false;
       }
       int len = utf8_arg.length() + 1;
       char* c_arg = new char[len];
       snprintf(c_arg, len, "%s", *utf8_arg);
       exec_args_[i] = c_arg;
     }
     exec_args_[i] = NULL;
     return true;
   }
@@ skipping 16 matching lines @@
 
 
 // Gets the optional timeouts from the arguments to the system() call.
 static bool GetTimeouts(const v8::FunctionCallbackInfo<v8::Value>& args,
                         int* read_timeout,
                         int* total_timeout) {
   if (args.Length() > 3) {
     if (args[3]->IsNumber()) {
       *total_timeout = args[3]->Int32Value();
     } else {
-      args.GetIsolate()->ThrowException(
-          String::New("system: Argument 4 must be a number"));
+      args.GetIsolate()->ThrowException(String::NewFromUtf8(
+          args.GetIsolate(), "system: Argument 4 must be a number"));
       return false;
     }
   }
   if (args.Length() > 2) {
     if (args[2]->IsNumber()) {
       *read_timeout = args[2]->Int32Value();
     } else {
-      args.GetIsolate()->ThrowException(
-          String::New("system: Argument 3 must be a number"));
+      args.GetIsolate()->ThrowException(String::NewFromUtf8(
+          args.GetIsolate(), "system: Argument 3 must be a number"));
       return false;
     }
   }
   return true;
 }
 
 
 static const int kReadFD = 0;
 static const int kWriteFD = 1;
 
@@ skipping 17 matching lines @@
   int bytes_written;
   do {
     bytes_written = write(exec_error_fds[kWriteFD], &err, sizeof(err));
   } while (bytes_written == -1 && errno == EINTR);
   // Return (and exit child process).
 }
 
 
 // Runs in the parent process.  Checks that the child was able to exec (closing
 // the file desriptor), or reports an error if it failed.
-static bool ChildLaunchedOK(int* exec_error_fds) {
+static bool ChildLaunchedOK(Isolate* isolate, int* exec_error_fds) {
   int bytes_read;
   int err;
   do {
     bytes_read = read(exec_error_fds[kReadFD], &err, sizeof(err));
   } while (bytes_read == -1 && errno == EINTR);
   if (bytes_read != 0) {
-    ThrowException(String::New(strerror(err)));
+    isolate->ThrowException(String::NewFromUtf8(isolate, strerror(err)));
     return false;
   }
   return true;
 }
 
 
 // Accumulates the output from the child in a string handle.  Returns true if it
 // succeeded or false if an exception was thrown.
-static Handle<Value> GetStdout(int child_fd,
+static Handle<Value> GetStdout(Isolate* isolate,
+                               int child_fd,
                                struct timeval& start_time,
                                int read_timeout,
                                int total_timeout) {
   Handle<String> accumulator = String::Empty();
 
   int fullness = 0;
   static const int kStdoutReadBufferSize = 4096;
   char buffer[kStdoutReadBufferSize];
 
   if (fcntl(child_fd, F_SETFL, O_NONBLOCK) != 0) {
-    return ThrowException(String::New(strerror(errno)));
+    return isolate->ThrowException(
+        String::NewFromUtf8(isolate, strerror(errno)));
   }
 
   int bytes_read;
   do {
     bytes_read = read(child_fd,
                       buffer + fullness,
                       kStdoutReadBufferSize - fullness);
     if (bytes_read == -1) {
       if (errno == EAGAIN) {
         if (!WaitOnFD(child_fd,
                       read_timeout,
                       total_timeout,
                       start_time) ||
             (TimeIsOut(start_time, total_timeout))) {
-          return ThrowException(String::New("Timed out waiting for output"));
+          return isolate->ThrowException(
+              String::NewFromUtf8(isolate, "Timed out waiting for output"));
         }
         continue;
       } else if (errno == EINTR) {
         continue;
       } else {
         break;
       }
     }
     if (bytes_read + fullness > 0) {
       int length = bytes_read == 0 ?
                    bytes_read + fullness :
                    LengthWithoutIncompleteUtf8(buffer, bytes_read + fullness);
-      Handle<String> addition = String::New(buffer, length);
+      Handle<String> addition =
+          String::NewFromUtf8(isolate, buffer, String::kNormalString, length);
       accumulator = String::Concat(accumulator, addition);
       fullness = bytes_read + fullness - length;
       memcpy(buffer, buffer + length, fullness);
     }
   } while (bytes_read != 0);
   return accumulator;
 }
 
 
 // Modern Linux has the waitid call, which is like waitpid, but more useful
 // if you want a timeout.  If we don't have waitid we can't limit the time
 // waiting for the process to exit without losing the information about
 // whether it exited normally.  In the common case this doesn't matter because
 // we don't get here before the child has closed stdout and most programs don't
 // do that before they exit.
 //
 // We're disabling usage of waitid in Mac OS X because it doens't work for us:
 // a parent process hangs on waiting while a child process is already a zombie.
 // See http://code.google.com/p/v8/issues/detail?id=401.
 #if defined(WNOWAIT) && !defined(ANDROID) && !defined(__APPLE__) \
     && !defined(__NetBSD__)
 #if !defined(__FreeBSD__)
 #define HAS_WAITID 1
 #endif
 #endif
 
 
 // Get exit status of child.
-static bool WaitForChild(int pid,
+static bool WaitForChild(Isolate* isolate,
+                         int pid,
                          ZombieProtector& child_waiter,
                          struct timeval& start_time,
                          int read_timeout,
                          int total_timeout) {
 #ifdef HAS_WAITID
 
   siginfo_t child_info;
   child_info.si_pid = 0;
   int useconds = 1;
   // Wait for child to exit.
   while (child_info.si_pid == 0) {
     waitid(P_PID, pid, &child_info, WEXITED | WNOHANG | WNOWAIT);
     usleep(useconds);
     if (useconds < 1000000) useconds <<= 1;
     if ((read_timeout != -1 && useconds / 1000 > read_timeout) ||
         (TimeIsOut(start_time, total_timeout))) {
-      ThrowException(String::New("Timed out waiting for process to terminate"));
+      isolate->ThrowException(String::NewFromUtf8(
+          isolate, "Timed out waiting for process to terminate"));
       kill(pid, SIGINT);
       return false;
     }
   }
   if (child_info.si_code == CLD_KILLED) {
     char message[999];
     snprintf(message,
              sizeof(message),
              "Child killed by signal %d",
              child_info.si_status);
-    ThrowException(String::New(message));
+    isolate->ThrowException(String::NewFromUtf8(isolate, message));
     return false;
   }
   if (child_info.si_code == CLD_EXITED && child_info.si_status != 0) {
     char message[999];
     snprintf(message,
              sizeof(message),
              "Child exited with status %d",
              child_info.si_status);
-    ThrowException(String::New(message));
+    isolate->ThrowException(String::NewFromUtf8(isolate, message));
     return false;
   }
 
 #else  // No waitid call.
 
   int child_status;
   waitpid(pid, &child_status, 0);  // We hang here if the child doesn't exit.
   child_waiter.ChildIsDeadNow();
   if (WIFSIGNALED(child_status)) {
     char message[999];
     snprintf(message,
              sizeof(message),
              "Child killed by signal %d",
              WTERMSIG(child_status));
-    ThrowException(String::New(message));
+    isolate->ThrowException(String::NewFromUtf8(isolate, message));
     return false;
   }
   if (WEXITSTATUS(child_status) != 0) {
     char message[999];
     int exit_status = WEXITSTATUS(child_status);
     snprintf(message,
              sizeof(message),
              "Child exited with status %d",
              exit_status);
-    ThrowException(String::New(message));
+    isolate->ThrowException(String::NewFromUtf8(isolate, message));
     return false;
   }
 
 #endif  // No waitid call.
 
   return true;
 }
 
 
 // Implementation of the system() function (see d8.h for details).
 void Shell::System(const v8::FunctionCallbackInfo<v8::Value>& args) {
   HandleScope scope(args.GetIsolate());
   int read_timeout = -1;
   int total_timeout = -1;
   if (!GetTimeouts(args, &read_timeout, &total_timeout)) return;
   Handle<Array> command_args;
   if (args.Length() > 1) {
     if (!args[1]->IsArray()) {
-      args.GetIsolate()->ThrowException(
-          String::New("system: Argument 2 must be an array"));
+      args.GetIsolate()->ThrowException(String::NewFromUtf8(
+          args.GetIsolate(), "system: Argument 2 must be an array"));
       return;
     }
     command_args = Handle<Array>::Cast(args[1]);
   } else {
     command_args = Array::New(0);
   }
   if (command_args->Length() > ExecArgs::kMaxArgs) {
-    args.GetIsolate()->ThrowException(
-        String::New("Too many arguments to system()"));
+    args.GetIsolate()->ThrowException(String::NewFromUtf8(
+        args.GetIsolate(), "Too many arguments to system()"));
     return;
   }
   if (args.Length() < 1) {
-    args.GetIsolate()->ThrowException(
-        String::New("Too few arguments to system()"));
+    args.GetIsolate()->ThrowException(String::NewFromUtf8(
+        args.GetIsolate(), "Too few arguments to system()"));
     return;
   }
 
   struct timeval start_time;
   gettimeofday(&start_time, NULL);
 
   ExecArgs exec_args;
-  if (!exec_args.Init(args[0], command_args)) {
+  if (!exec_args.Init(args.GetIsolate(), args[0], command_args)) {
     return;
   }
   int exec_error_fds[2];
   int stdout_fds[2];
 
   if (pipe(exec_error_fds) != 0) {
     args.GetIsolate()->ThrowException(
-        String::New("pipe syscall failed."));
+        String::NewFromUtf8(args.GetIsolate(), "pipe syscall failed."));
     return;
   }
   if (pipe(stdout_fds) != 0) {
     args.GetIsolate()->ThrowException(
-        String::New("pipe syscall failed."));
+        String::NewFromUtf8(args.GetIsolate(), "pipe syscall failed."));
     return;
   }
 
   pid_t pid = fork();
   if (pid == 0) {  // Child process.
     ExecSubprocess(exec_error_fds, stdout_fds, exec_args);
     exit(1);
   }
 
   // Parent process.  Ensure that we clean up if we exit this function early.
   ZombieProtector child_waiter(pid);
   close(exec_error_fds[kWriteFD]);
   close(stdout_fds[kWriteFD]);
   OpenFDCloser error_read_closer(exec_error_fds[kReadFD]);
   OpenFDCloser stdout_read_closer(stdout_fds[kReadFD]);
 
-  if (!ChildLaunchedOK(exec_error_fds)) return;
+  if (!ChildLaunchedOK(args.GetIsolate(), exec_error_fds)) return;
 
-  Handle<Value> accumulator = GetStdout(stdout_fds[kReadFD],
+  Handle<Value> accumulator = GetStdout(args.GetIsolate(),
+                                        stdout_fds[kReadFD],
                                         start_time,
                                         read_timeout,
                                         total_timeout);
   if (accumulator->IsUndefined()) {
     kill(pid, SIGINT);  // On timeout, kill the subprocess.
     args.GetReturnValue().Set(accumulator);
     return;
   }
 
-  if (!WaitForChild(pid,
+  if (!WaitForChild(args.GetIsolate(),
+                    pid,
                     child_waiter,
                     start_time,
                     read_timeout,
                     total_timeout)) {
     return;
   }
 
   args.GetReturnValue().Set(accumulator);
 }
 
 
 void Shell::ChangeDirectory(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() != 1) {
     const char* message = "chdir() takes one argument";
-    args.GetIsolate()->ThrowException(String::New(message));
+    args.GetIsolate()->ThrowException(
+        String::NewFromUtf8(args.GetIsolate(), message));
     return;
   }
   String::Utf8Value directory(args[0]);
   if (*directory == NULL) {
     const char* message = "os.chdir(): String conversion of argument failed.";
-    args.GetIsolate()->ThrowException(String::New(message));
+    args.GetIsolate()->ThrowException(
+        String::NewFromUtf8(args.GetIsolate(), message));
     return;
   }
   if (chdir(*directory) != 0) {
-    args.GetIsolate()->ThrowException(String::New(strerror(errno)));
+    args.GetIsolate()->ThrowException(
+        String::NewFromUtf8(args.GetIsolate(), strerror(errno)));
     return;
   }
 }
 
 
 void Shell::SetUMask(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() != 1) {
     const char* message = "umask() takes one argument";
-    args.GetIsolate()->ThrowException(String::New(message));
+    args.GetIsolate()->ThrowException(
+        String::NewFromUtf8(args.GetIsolate(), message));
     return;
   }
   if (args[0]->IsNumber()) {
     mode_t mask = args[0]->Int32Value();
     int previous = umask(mask);
     args.GetReturnValue().Set(previous);
     return;
   } else {
     const char* message = "umask() argument must be numeric";
-    args.GetIsolate()->ThrowException(String::New(message));
+    args.GetIsolate()->ThrowException(
+        String::NewFromUtf8(args.GetIsolate(), message));
     return;
   }
 }
 
 
-static bool CheckItsADirectory(char* directory) {
+static bool CheckItsADirectory(Isolate* isolate, char* directory) {
   struct stat stat_buf;
   int stat_result = stat(directory, &stat_buf);
   if (stat_result != 0) {
-    ThrowException(String::New(strerror(errno)));
+    isolate->ThrowException(String::NewFromUtf8(isolate, strerror(errno)));
     return false;
   }
   if ((stat_buf.st_mode & S_IFDIR) != 0) return true;
-  ThrowException(String::New(strerror(EEXIST)));
+  isolate->ThrowException(String::NewFromUtf8(isolate, strerror(EEXIST)));
   return false;
 }
 
 
 // Returns true for success.  Creates intermediate directories as needed.  No
 // error if the directory exists already.
-static bool mkdirp(char* directory, mode_t mask) {
+static bool mkdirp(Isolate* isolate, char* directory, mode_t mask) {
   int result = mkdir(directory, mask);
   if (result == 0) return true;
   if (errno == EEXIST) {
-    return CheckItsADirectory(directory);
+    return CheckItsADirectory(isolate, directory);
   } else if (errno == ENOENT) {  // Intermediate path element is missing.
     char* last_slash = strrchr(directory, '/');
     if (last_slash == NULL) {
-      ThrowException(String::New(strerror(errno)));
+      isolate->ThrowException(String::NewFromUtf8(isolate, strerror(errno)));
       return false;
     }
     *last_slash = 0;
-    if (!mkdirp(directory, mask)) return false;
+    if (!mkdirp(isolate, directory, mask)) return false;
     *last_slash = '/';
     result = mkdir(directory, mask);
     if (result == 0) return true;
     if (errno == EEXIST) {
-      return CheckItsADirectory(directory);
+      return CheckItsADirectory(isolate, directory);
     }
-    ThrowException(String::New(strerror(errno)));
+    isolate->ThrowException(String::NewFromUtf8(isolate, strerror(errno)));
     return false;
   } else {
-    ThrowException(String::New(strerror(errno)));
+    isolate->ThrowException(String::NewFromUtf8(isolate, strerror(errno)));
     return false;
   }
 }
 
 
 void Shell::MakeDirectory(const v8::FunctionCallbackInfo<v8::Value>& args) {
   mode_t mask = 0777;
   if (args.Length() == 2) {
     if (args[1]->IsNumber()) {
       mask = args[1]->Int32Value();
     } else {
       const char* message = "mkdirp() second argument must be numeric";
-      args.GetIsolate()->ThrowException(String::New(message));
+      args.GetIsolate()->ThrowException(
+          String::NewFromUtf8(args.GetIsolate(), message));
       return;
     }
   } else if (args.Length() != 1) {
     const char* message = "mkdirp() takes one or two arguments";
-    args.GetIsolate()->ThrowException(String::New(message));
+    args.GetIsolate()->ThrowException(
+        String::NewFromUtf8(args.GetIsolate(), message));
     return;
   }
   String::Utf8Value directory(args[0]);
   if (*directory == NULL) {
     const char* message = "os.mkdirp(): String conversion of argument failed.";
-    args.GetIsolate()->ThrowException(String::New(message));
+    args.GetIsolate()->ThrowException(
+        String::NewFromUtf8(args.GetIsolate(), message));
     return;
   }
-  mkdirp(*directory, mask);
+  mkdirp(args.GetIsolate(), *directory, mask);
 }
 
 
 void Shell::RemoveDirectory(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() != 1) {
     const char* message = "rmdir() takes one or two arguments";
-    args.GetIsolate()->ThrowException(String::New(message));
+    args.GetIsolate()->ThrowException(
+        String::NewFromUtf8(args.GetIsolate(), message));
     return;
   }
   String::Utf8Value directory(args[0]);
   if (*directory == NULL) {
     const char* message = "os.rmdir(): String conversion of argument failed.";
-    args.GetIsolate()->ThrowException(String::New(message));
+    args.GetIsolate()->ThrowException(
+        String::NewFromUtf8(args.GetIsolate(), message));
     return;
   }
   rmdir(*directory);
 }
 
 
 void Shell::SetEnvironment(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() != 2) {
     const char* message = "setenv() takes two arguments";
-    args.GetIsolate()->ThrowException(String::New(message));
+    args.GetIsolate()->ThrowException(
+        String::NewFromUtf8(args.GetIsolate(), message));
     return;
   }
   String::Utf8Value var(args[0]);
   String::Utf8Value value(args[1]);
   if (*var == NULL) {
     const char* message =
         "os.setenv(): String conversion of variable name failed.";
-    args.GetIsolate()->ThrowException(String::New(message));
+    args.GetIsolate()->ThrowException(
+        String::NewFromUtf8(args.GetIsolate(), message));
     return;
   }
   if (*value == NULL) {
     const char* message =
         "os.setenv(): String conversion of variable contents failed.";
-    args.GetIsolate()->ThrowException(String::New(message));
+    args.GetIsolate()->ThrowException(
+        String::NewFromUtf8(args.GetIsolate(), message));
     return;
   }
   setenv(*var, *value, 1);
 }
 
 
 void Shell::UnsetEnvironment(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() != 1) {
     const char* message = "unsetenv() takes one argument";
-    args.GetIsolate()->ThrowException(String::New(message));
+    args.GetIsolate()->ThrowException(
+        String::NewFromUtf8(args.GetIsolate(), message));
     return;
   }
   String::Utf8Value var(args[0]);
   if (*var == NULL) {
     const char* message =
         "os.setenv(): String conversion of variable name failed.";
-    args.GetIsolate()->ThrowException(String::New(message));
+    args.GetIsolate()->ThrowException(
+        String::NewFromUtf8(args.GetIsolate(), message));
     return;
   }
   unsetenv(*var);
 }
 
 
-void Shell::AddOSMethods(Handle<ObjectTemplate> os_templ) {
-  os_templ->Set(String::New("system"), FunctionTemplate::New(System));
-  os_templ->Set(String::New("chdir"), FunctionTemplate::New(ChangeDirectory));
-  os_templ->Set(String::New("setenv"), FunctionTemplate::New(SetEnvironment));
-  os_templ->Set(String::New("unsetenv"),
+void Shell::AddOSMethods(Isolate* isolate, Handle<ObjectTemplate> os_templ) {
+  os_templ->Set(String::NewFromUtf8(isolate, "system"),
+                FunctionTemplate::New(System));
+  os_templ->Set(String::NewFromUtf8(isolate, "chdir"),
+                FunctionTemplate::New(ChangeDirectory));
+  os_templ->Set(String::NewFromUtf8(isolate, "setenv"),
+                FunctionTemplate::New(SetEnvironment));
+  os_templ->Set(String::NewFromUtf8(isolate, "unsetenv"),
                 FunctionTemplate::New(UnsetEnvironment));
-  os_templ->Set(String::New("umask"), FunctionTemplate::New(SetUMask));
-  os_templ->Set(String::New("mkdirp"), FunctionTemplate::New(MakeDirectory));
-  os_templ->Set(String::New("rmdir"), FunctionTemplate::New(RemoveDirectory));
+  os_templ->Set(String::NewFromUtf8(isolate, "umask"),
+                FunctionTemplate::New(SetUMask));
+  os_templ->Set(String::NewFromUtf8(isolate, "mkdirp"),
+                FunctionTemplate::New(MakeDirectory));
+  os_templ->Set(String::NewFromUtf8(isolate, "rmdir"),
+                FunctionTemplate::New(RemoveDirectory));
 }
 
 }  // namespace v8