From e8cbacd0671872bd6adb3dbaf83156228ff62448 Mon Sep 17 00:00:00 2001 From: cjihrig Date: Mon, 16 Oct 2017 20:26:10 -0400 Subject: [PATCH] src: increase usage of context in process_wrap.cc Refs: https://github.com/nodejs/node/pull/15380 PR-URL: https://github.com/nodejs/node/pull/16247 Reviewed-By: Ben Noordhuis Reviewed-By: James M Snell --- src/process_wrap.cc | 76 +++++++++++++++++++++++++++++---------------- 1 file changed, 49 insertions(+), 27 deletions(-) diff --git a/src/process_wrap.cc b/src/process_wrap.cc index 6613a571891a7f..d5a408af692111 100644 --- a/src/process_wrap.cc +++ b/src/process_wrap.cc @@ -93,16 +93,20 @@ class ProcessWrap : public HandleWrap { static void ParseStdioOptions(Environment* env, Local js_options, uv_process_options_t* options) { + Local context = env->context(); Local stdio_key = env->stdio_string(); - Local stdios = js_options->Get(stdio_key).As(); + Local stdios = + js_options->Get(context, stdio_key).ToLocalChecked().As(); uint32_t len = stdios->Length(); options->stdio = new uv_stdio_container_t[len]; options->stdio_count = len; for (uint32_t i = 0; i < len; i++) { - Local stdio = stdios->Get(i).As(); - Local type = stdio->Get(env->type_string()); + Local stdio = + stdios->Get(context, i).ToLocalChecked().As(); + Local type = + stdio->Get(context, env->type_string()).ToLocalChecked(); if (type->Equals(env->ignore_string())) { options->stdio[i].flags = UV_IGNORE; @@ -110,14 +114,16 @@ class ProcessWrap : public HandleWrap { options->stdio[i].flags = static_cast( UV_CREATE_PIPE | UV_READABLE_PIPE | UV_WRITABLE_PIPE); Local handle_key = env->handle_string(); - Local handle = stdio->Get(handle_key).As(); + Local handle = + stdio->Get(context, handle_key).ToLocalChecked().As(); CHECK(!handle.IsEmpty()); options->stdio[i].data.stream = reinterpret_cast( Unwrap(handle)->UVHandle()); } else if (type->Equals(env->wrap_string())) { Local handle_key = env->handle_string(); - Local handle = stdio->Get(handle_key).As(); + Local handle = + stdio->Get(context, handle_key).ToLocalChecked().As(); uv_stream_t* stream = HandleToStream(env, handle); CHECK_NE(stream, nullptr); @@ -125,7 +131,8 @@ class ProcessWrap : public HandleWrap { options->stdio[i].data.stream = stream; } else { Local fd_key = env->fd_string(); - int fd = static_cast(stdio->Get(fd_key)->IntegerValue()); + int fd = static_cast( + stdio->Get(context, fd_key).ToLocalChecked()->IntegerValue()); options->stdio[i].flags = UV_INHERIT_FD; options->stdio[i].data.fd = fd; } @@ -134,7 +141,7 @@ class ProcessWrap : public HandleWrap { static void Spawn(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); - + Local context = env->context(); ProcessWrap* wrap; ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder()); @@ -146,19 +153,21 @@ class ProcessWrap : public HandleWrap { options.exit_cb = OnExit; // options.uid - Local uid_v = js_options->Get(env->uid_string()); + Local uid_v = + js_options->Get(context, env->uid_string()).ToLocalChecked(); if (!uid_v->IsUndefined() && !uid_v->IsNull()) { CHECK(uid_v->IsInt32()); - const int32_t uid = uid_v->Int32Value(env->context()).FromJust(); + const int32_t uid = uid_v->Int32Value(context).FromJust(); options.flags |= UV_PROCESS_SETUID; options.uid = static_cast(uid); } // options.gid - Local gid_v = js_options->Get(env->gid_string()); + Local gid_v = + js_options->Get(context, env->gid_string()).ToLocalChecked(); if (!gid_v->IsUndefined() && !gid_v->IsNull()) { CHECK(gid_v->IsInt32()); - const int32_t gid = gid_v->Int32Value(env->context()).FromJust(); + const int32_t gid = gid_v->Int32Value(context).FromJust(); options.flags |= UV_PROCESS_SETGID; options.gid = static_cast(gid); } @@ -166,20 +175,23 @@ class ProcessWrap : public HandleWrap { // TODO(bnoordhuis) is this possible to do without mallocing ? // options.file - Local file_v = js_options->Get(env->file_string()); + Local file_v = + js_options->Get(context, env->file_string()).ToLocalChecked(); CHECK(file_v->IsString()); node::Utf8Value file(env->isolate(), file_v); options.file = *file; // options.args - Local argv_v = js_options->Get(env->args_string()); + Local argv_v = + js_options->Get(context, env->args_string()).ToLocalChecked(); if (!argv_v.IsEmpty() && argv_v->IsArray()) { Local js_argv = Local::Cast(argv_v); int argc = js_argv->Length(); // Heap allocate to detect errors. +1 is for nullptr. options.args = new char*[argc + 1]; for (int i = 0; i < argc; i++) { - node::Utf8Value arg(env->isolate(), js_argv->Get(i)); + node::Utf8Value arg(env->isolate(), + js_argv->Get(context, i).ToLocalChecked()); options.args[i] = strdup(*arg); CHECK_NE(options.args[i], nullptr); } @@ -187,7 +199,8 @@ class ProcessWrap : public HandleWrap { } // options.cwd - Local cwd_v = js_options->Get(env->cwd_string()); + Local cwd_v = + js_options->Get(context, env->cwd_string()).ToLocalChecked(); node::Utf8Value cwd(env->isolate(), cwd_v->IsString() ? cwd_v : Local()); if (cwd.length() > 0) { @@ -195,13 +208,15 @@ class ProcessWrap : public HandleWrap { } // options.env - Local env_v = js_options->Get(env->env_pairs_string()); + Local env_v = + js_options->Get(context, env->env_pairs_string()).ToLocalChecked(); if (!env_v.IsEmpty() && env_v->IsArray()) { Local env_opt = Local::Cast(env_v); int envc = env_opt->Length(); options.env = new char*[envc + 1]; // Heap allocated to detect errors. for (int i = 0; i < envc; i++) { - node::Utf8Value pair(env->isolate(), env_opt->Get(i)); + node::Utf8Value pair(env->isolate(), + env_opt->Get(context, i).ToLocalChecked()); options.env[i] = strdup(*pair); CHECK_NE(options.env[i], nullptr); } @@ -212,22 +227,27 @@ class ProcessWrap : public HandleWrap { ParseStdioOptions(env, js_options, &options); // options.windowsHide - Local windows_hide_key = env->windows_hide_string(); + Local hide_v = + js_options->Get(context, env->windows_hide_string()).ToLocalChecked(); - if (js_options->Get(windows_hide_key)->IsTrue()) { + if (hide_v->IsTrue()) { options.flags |= UV_PROCESS_WINDOWS_HIDE; } // options.windows_verbatim_arguments - Local windows_verbatim_arguments_key = - env->windows_verbatim_arguments_string(); - if (js_options->Get(windows_verbatim_arguments_key)->IsTrue()) { + Local wva_v = + js_options->Get(context, env->windows_verbatim_arguments_string()) + .ToLocalChecked(); + + if (wva_v->IsTrue()) { options.flags |= UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS; } // options.detached - Local detached_key = env->detached_string(); - if (js_options->Get(detached_key)->IsTrue()) { + Local detached_v = + js_options->Get(context, env->detached_string()).ToLocalChecked(); + + if (detached_v->IsTrue()) { options.flags |= UV_PROCESS_DETACHED; } @@ -235,8 +255,9 @@ class ProcessWrap : public HandleWrap { if (err == 0) { CHECK_EQ(wrap->process_.data, wrap); - wrap->object()->Set(env->pid_string(), - Integer::New(env->isolate(), wrap->process_.pid)); + wrap->object()->Set(context, env->pid_string(), + Integer::New(env->isolate(), + wrap->process_.pid)).FromJust(); } if (options.args) { @@ -255,9 +276,10 @@ class ProcessWrap : public HandleWrap { } static void Kill(const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); ProcessWrap* wrap; ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder()); - int signal = args[0]->Int32Value(); + int signal = args[0]->Int32Value(env->context()).FromJust(); int err = uv_process_kill(&wrap->process_, signal); args.GetReturnValue().Set(err); }