Skip to content

Commit 3d103ec

Browse files
jasnelladuh95
jasnell
authored and
aduh95
committedMar 9, 2025
src: improve error handling in spawn_sync
Replacing more ToLocalChecked uses. PR-URL: #57185 Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com> Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
·
v23.11.0v23.10.0
1 parent 041a217 commit 3d103ec

File tree

2 files changed

+244
-144
lines changed

2 files changed

+244
-144
lines changed
 

Diff for: ‎src/spawn_sync.cc

+238-139
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,7 @@
2222
#include "spawn_sync.h"
2323
#include "debug_utils-inl.h"
2424
#include "env-inl.h"
25+
#include "node_errors.h"
2526
#include "node_external_reference.h"
2627
#include "node_internals.h"
2728
#include "string_bytes.h"
@@ -185,15 +186,17 @@ void SyncProcessStdioPipe::Close() {
185186
lifecycle_ = kClosing;
186187
}
187188

188-
189-
Local<Object> SyncProcessStdioPipe::GetOutputAsBuffer(Environment* env) const {
189+
MaybeLocal<Object> SyncProcessStdioPipe::GetOutputAsBuffer(
190+
Environment* env) const {
190191
size_t length = OutputLength();
191-
Local<Object> js_buffer = Buffer::New(env, length).ToLocalChecked();
192+
Local<Object> js_buffer;
193+
if (!Buffer::New(env, length).ToLocal(&js_buffer)) {
194+
return MaybeLocal<Object>();
195+
}
192196
CopyOutput(Buffer::Data(js_buffer));
193197
return js_buffer;
194198
}
195199

196-
197200
bool SyncProcessStdioPipe::readable() const {
198201
return readable_;
199202
}
@@ -446,7 +449,10 @@ MaybeLocal<Object> SyncProcessRunner::Run(Local<Value> options) {
446449
CloseHandlesAndDeleteLoop();
447450
if (r.IsNothing()) return MaybeLocal<Object>();
448451

449-
Local<Object> result = BuildResultObject();
452+
Local<Object> result;
453+
if (!BuildResultObject().ToLocal(&result)) {
454+
return MaybeLocal<Object>();
455+
}
450456

451457
return scope.Escape(result);
452458
}
@@ -679,58 +685,80 @@ void SyncProcessRunner::SetPipeError(int pipe_error) {
679685
pipe_error_ = pipe_error;
680686
}
681687

682-
683-
Local<Object> SyncProcessRunner::BuildResultObject() {
688+
MaybeLocal<Object> SyncProcessRunner::BuildResultObject() {
684689
EscapableHandleScope scope(env()->isolate());
685690
Local<Context> context = env()->context();
686691

687692
Local<Object> js_result = Object::New(env()->isolate());
688693

689-
if (GetError() != 0) {
690-
js_result->Set(context, env()->error_string(),
691-
Integer::New(env()->isolate(), GetError())).Check();
694+
if (GetError() != 0 && js_result
695+
->Set(context,
696+
env()->error_string(),
697+
Integer::New(env()->isolate(), GetError()))
698+
.IsNothing()) {
699+
return MaybeLocal<Object>();
692700
}
693701

694702
if (exit_status_ >= 0) {
695703
if (term_signal_ > 0) {
696-
js_result->Set(context, env()->status_string(),
697-
Null(env()->isolate())).Check();
698-
} else {
699-
js_result->Set(context, env()->status_string(),
700-
Number::New(env()->isolate(),
701-
static_cast<double>(exit_status_))).Check();
704+
if (js_result
705+
->Set(context, env()->status_string(), Null(env()->isolate()))
706+
.IsNothing()) {
707+
return MaybeLocal<Object>();
708+
}
709+
} else if (js_result
710+
->Set(context,
711+
env()->status_string(),
712+
Number::New(env()->isolate(),
713+
static_cast<double>(exit_status_)))
714+
.IsNothing()) {
715+
return MaybeLocal<Object>();
702716
}
703-
} else {
704717
// If exit_status_ < 0 the process was never started because of some error.
705-
js_result->Set(context, env()->status_string(),
706-
Null(env()->isolate())).Check();
718+
} else if (js_result
719+
->Set(context, env()->status_string(), Null(env()->isolate()))
720+
.IsNothing()) {
721+
return MaybeLocal<Object>();
707722
}
708723

709-
if (term_signal_ > 0)
710-
js_result
711-
->Set(context,
712-
env()->signal_string(),
713-
OneByteString(env()->isolate(), signo_string(term_signal_)))
714-
.Check();
715-
else
716-
js_result->Set(context, env()->signal_string(),
717-
Null(env()->isolate())).Check();
724+
if (term_signal_ > 0) {
725+
if (js_result
726+
->Set(context,
727+
env()->signal_string(),
728+
OneByteString(env()->isolate(), signo_string(term_signal_)))
729+
.IsNothing()) {
730+
return MaybeLocal<Object>();
731+
}
732+
} else if (js_result
733+
->Set(context, env()->signal_string(), Null(env()->isolate()))
734+
.IsNothing()) {
735+
return MaybeLocal<Object>();
736+
}
718737

719-
if (exit_status_ >= 0)
720-
js_result->Set(context, env()->output_string(),
721-
BuildOutputArray()).Check();
722-
else
723-
js_result->Set(context, env()->output_string(),
724-
Null(env()->isolate())).Check();
738+
if (exit_status_ >= 0) {
739+
Local<Array> out;
740+
if (!BuildOutputArray().ToLocal(&out) ||
741+
js_result->Set(context, env()->output_string(), out).IsNothing()) {
742+
return MaybeLocal<Object>();
743+
}
744+
} else if (js_result
745+
->Set(context, env()->output_string(), Null(env()->isolate()))
746+
.IsNothing()) {
747+
return MaybeLocal<Object>();
748+
}
725749

726-
js_result->Set(context, env()->pid_string(),
727-
Number::New(env()->isolate(), uv_process_.pid)).Check();
750+
if (js_result
751+
->Set(context,
752+
env()->pid_string(),
753+
Number::New(env()->isolate(), uv_process_.pid))
754+
.IsNothing()) {
755+
return MaybeLocal<Object>();
756+
}
728757

729758
return scope.Escape(js_result);
730759
}
731760

732-
733-
Local<Array> SyncProcessRunner::BuildOutputArray() {
761+
MaybeLocal<Array> SyncProcessRunner::BuildOutputArray() {
734762
CHECK_GE(lifecycle_, kInitialized);
735763
CHECK(!stdio_pipes_.empty());
736764

@@ -739,10 +767,14 @@ Local<Array> SyncProcessRunner::BuildOutputArray() {
739767

740768
for (uint32_t i = 0; i < stdio_pipes_.size(); i++) {
741769
SyncProcessStdioPipe* h = stdio_pipes_[i].get();
742-
if (h != nullptr && h->writable())
743-
js_output[i] = h->GetOutputAsBuffer(env());
744-
else
770+
if (h == nullptr || !h->writable()) {
745771
js_output[i] = Null(env()->isolate());
772+
continue;
773+
}
774+
775+
if (!h->GetOutputAsBuffer(env()).ToLocal(&js_output[i])) {
776+
return MaybeLocal<Array>();
777+
}
746778
}
747779

748780
return scope.Escape(
@@ -759,9 +791,11 @@ Maybe<int> SyncProcessRunner::ParseOptions(Local<Value> js_value) {
759791
Local<Context> context = env()->context();
760792
Local<Object> js_options = js_value.As<Object>();
761793

762-
Local<Value> js_file =
763-
js_options->Get(context, env()->file_string()).ToLocalChecked();
764-
if (!CopyJsString(js_file, &file_buffer_).To(&r)) return Nothing<int>();
794+
Local<Value> js_file;
795+
if (!js_options->Get(context, env()->file_string()).ToLocal(&js_file) ||
796+
!CopyJsString(js_file, &file_buffer_).To(&r)) {
797+
return Nothing<int>();
798+
}
765799
if (r < 0) return Just(r);
766800
uv_process_options_.file = file_buffer_;
767801

@@ -774,104 +808,154 @@ Maybe<int> SyncProcessRunner::ParseOptions(Local<Value> js_value) {
774808
return Just<int>(UV_EINVAL);
775809
#endif
776810

777-
Local<Value> js_args =
778-
js_options->Get(context, env()->args_string()).ToLocalChecked();
779-
if (!CopyJsStringArray(js_args, &args_buffer_).To(&r)) return Nothing<int>();
811+
Local<Value> js_args;
812+
if (!js_options->Get(context, env()->args_string()).ToLocal(&js_args) ||
813+
!CopyJsStringArray(js_args, &args_buffer_).To(&r)) {
814+
return Nothing<int>();
815+
}
780816
if (r < 0) return Just(r);
781817
uv_process_options_.args = reinterpret_cast<char**>(args_buffer_);
782818

783-
Local<Value> js_cwd =
784-
js_options->Get(context, env()->cwd_string()).ToLocalChecked();
785-
if (IsSet(js_cwd)) {
786-
if (!CopyJsString(js_cwd, &cwd_buffer_).To(&r)) return Nothing<int>();
819+
Local<Value> js_cwd;
820+
if (!js_options->Get(context, env()->cwd_string()).ToLocal(&js_cwd)) {
821+
return Nothing<int>();
822+
}
823+
if (!js_cwd->IsNullOrUndefined()) {
824+
if (!CopyJsString(js_cwd, &cwd_buffer_).To(&r)) {
825+
return Nothing<int>();
826+
}
787827
if (r < 0) return Just(r);
788828
uv_process_options_.cwd = cwd_buffer_;
789829
}
790830

791-
Local<Value> js_env_pairs =
792-
js_options->Get(context, env()->env_pairs_string()).ToLocalChecked();
793-
if (IsSet(js_env_pairs)) {
794-
if (!CopyJsStringArray(js_env_pairs, &env_buffer_).To(&r))
831+
Local<Value> js_env_pairs;
832+
if (!js_options->Get(context, env()->env_pairs_string())
833+
.ToLocal(&js_env_pairs)) {
834+
return Nothing<int>();
835+
}
836+
if (!js_env_pairs->IsNullOrUndefined()) {
837+
if (!CopyJsStringArray(js_env_pairs, &env_buffer_).To(&r)) {
795838
return Nothing<int>();
839+
}
796840
if (r < 0) return Just(r);
797841

798842
uv_process_options_.env = reinterpret_cast<char**>(env_buffer_);
799843
}
800-
Local<Value> js_uid =
801-
js_options->Get(context, env()->uid_string()).ToLocalChecked();
802-
if (IsSet(js_uid)) {
803-
CHECK(js_uid->IsInt32());
844+
Local<Value> js_uid;
845+
if (!js_options->Get(context, env()->uid_string()).ToLocal(&js_uid)) {
846+
return Nothing<int>();
847+
}
848+
if (!js_uid->IsNullOrUndefined()) {
849+
if (!js_uid->IsInt32()) {
850+
THROW_ERR_INVALID_ARG_TYPE(env(),
851+
"options.uid must be a 32-bit signed integer");
852+
return Nothing<int>();
853+
}
804854
const int32_t uid = js_uid.As<Int32>()->Value();
805855
uv_process_options_.uid = static_cast<uv_uid_t>(uid);
806856
uv_process_options_.flags |= UV_PROCESS_SETUID;
807857
}
808858

809-
Local<Value> js_gid =
810-
js_options->Get(context, env()->gid_string()).ToLocalChecked();
811-
if (IsSet(js_gid)) {
812-
CHECK(js_gid->IsInt32());
859+
Local<Value> js_gid;
860+
if (!js_options->Get(context, env()->gid_string()).ToLocal(&js_gid)) {
861+
return Nothing<int>();
862+
}
863+
if (!js_gid->IsNullOrUndefined()) {
864+
if (!js_gid->IsInt32()) {
865+
THROW_ERR_INVALID_ARG_TYPE(env(),
866+
"options.gid must be a 32-bit signed integer");
867+
return Nothing<int>();
868+
}
813869
const int32_t gid = js_gid.As<Int32>()->Value();
814870
uv_process_options_.gid = static_cast<uv_gid_t>(gid);
815871
uv_process_options_.flags |= UV_PROCESS_SETGID;
816872
}
817873

818-
Local<Value> js_detached =
819-
js_options->Get(context, env()->detached_string()).ToLocalChecked();
820-
if (js_detached->BooleanValue(isolate))
874+
Local<Value> js_detached;
875+
if (!js_options->Get(context, env()->detached_string())
876+
.ToLocal(&js_detached)) {
877+
return Nothing<int>();
878+
}
879+
if (js_detached->BooleanValue(isolate)) {
821880
uv_process_options_.flags |= UV_PROCESS_DETACHED;
881+
}
822882

823-
Local<Value> js_win_hide =
824-
js_options->Get(context, env()->windows_hide_string()).ToLocalChecked();
825-
if (js_win_hide->BooleanValue(isolate))
883+
Local<Value> js_win_hide;
884+
if (!js_options->Get(context, env()->windows_hide_string())
885+
.ToLocal(&js_win_hide)) {
886+
return Nothing<int>();
887+
}
888+
if (js_win_hide->BooleanValue(isolate)) {
826889
uv_process_options_.flags |= UV_PROCESS_WINDOWS_HIDE;
890+
}
827891

828-
if (env()->hide_console_windows())
892+
if (env()->hide_console_windows()) {
829893
uv_process_options_.flags |= UV_PROCESS_WINDOWS_HIDE_CONSOLE;
894+
}
830895

831-
Local<Value> js_wva =
832-
js_options->Get(context, env()->windows_verbatim_arguments_string())
833-
.ToLocalChecked();
896+
Local<Value> js_wva;
897+
if (!js_options->Get(context, env()->windows_verbatim_arguments_string())
898+
.ToLocal(&js_wva)) {
899+
return Nothing<int>();
900+
}
834901

835-
if (js_wva->BooleanValue(isolate))
902+
if (js_wva->BooleanValue(isolate)) {
836903
uv_process_options_.flags |= UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS;
904+
}
837905

838-
Local<Value> js_timeout =
839-
js_options->Get(context, env()->timeout_string()).ToLocalChecked();
840-
if (IsSet(js_timeout)) {
841-
CHECK(js_timeout->IsNumber());
906+
Local<Value> js_timeout;
907+
if (!js_options->Get(context, env()->timeout_string()).ToLocal(&js_timeout)) {
908+
return Nothing<int>();
909+
}
910+
if (!js_timeout->IsNullOrUndefined()) {
911+
if (!js_timeout->IsNumber()) {
912+
THROW_ERR_INVALID_ARG_TYPE(env(), "options.timeout must be a number");
913+
return Nothing<int>();
914+
}
842915
int64_t timeout = js_timeout->IntegerValue(context).FromJust();
843916
timeout_ = static_cast<uint64_t>(timeout);
844917
}
845918

846-
Local<Value> js_max_buffer =
847-
js_options->Get(context, env()->max_buffer_string()).ToLocalChecked();
848-
if (IsSet(js_max_buffer)) {
849-
CHECK(js_max_buffer->IsNumber());
919+
Local<Value> js_max_buffer;
920+
if (!js_options->Get(context, env()->max_buffer_string())
921+
.ToLocal(&js_max_buffer)) {
922+
return Nothing<int>();
923+
}
924+
if (!js_max_buffer->IsNullOrUndefined()) {
925+
if (!js_max_buffer->IsNumber()) {
926+
THROW_ERR_INVALID_ARG_TYPE(env(), "options.maxBuffer must be a number");
927+
return Nothing<int>();
928+
}
850929
max_buffer_ = js_max_buffer->NumberValue(context).FromJust();
851930
}
852931

853-
Local<Value> js_kill_signal =
854-
js_options->Get(context, env()->kill_signal_string()).ToLocalChecked();
855-
if (IsSet(js_kill_signal)) {
856-
CHECK(js_kill_signal->IsInt32());
932+
Local<Value> js_kill_signal;
933+
if (!js_options->Get(context, env()->kill_signal_string())
934+
.ToLocal(&js_kill_signal)) {
935+
return Nothing<int>();
936+
}
937+
if (!js_kill_signal->IsNullOrUndefined()) {
938+
if (!js_kill_signal->IsNumber()) {
939+
THROW_ERR_INVALID_ARG_TYPE(env(), "options.killSignal must be a number");
940+
return Nothing<int>();
941+
}
857942
kill_signal_ = js_kill_signal.As<Int32>()->Value();
858943
}
859944

860-
Local<Value> js_stdio =
861-
js_options->Get(context, env()->stdio_string()).ToLocalChecked();
862-
r = ParseStdioOptions(js_stdio);
863-
if (r < 0) return Just(r);
945+
Local<Value> js_stdio;
946+
if (!js_options->Get(context, env()->stdio_string()).ToLocal(&js_stdio) ||
947+
!ParseStdioOptions(js_stdio).To(&r)) {
948+
return Nothing<int>();
949+
}
864950

865-
return Just(0);
951+
return Just(r);
866952
}
867953

868-
869-
int SyncProcessRunner::ParseStdioOptions(Local<Value> js_value) {
954+
Maybe<int> SyncProcessRunner::ParseStdioOptions(Local<Value> js_value) {
870955
HandleScope scope(env()->isolate());
871956
Local<Array> js_stdio_options;
872957

873-
if (!js_value->IsArray())
874-
return UV_EINVAL;
958+
if (!js_value->IsArray()) return Just<int>(UV_EINVAL);
875959

876960
Local<Context> context = env()->context();
877961
js_stdio_options = js_value.As<Array>();
@@ -884,73 +968,90 @@ int SyncProcessRunner::ParseStdioOptions(Local<Value> js_value) {
884968
stdio_pipes_initialized_ = true;
885969

886970
for (uint32_t i = 0; i < stdio_count_; i++) {
887-
Local<Value> js_stdio_option =
888-
js_stdio_options->Get(context, i).ToLocalChecked();
971+
Local<Value> js_stdio_option;
972+
if (!js_stdio_options->Get(context, i).ToLocal(&js_stdio_option)) {
973+
return Nothing<int>();
974+
}
889975

890-
if (!js_stdio_option->IsObject())
891-
return UV_EINVAL;
976+
if (!js_stdio_option->IsObject()) {
977+
return Just<int>(UV_EINVAL);
978+
}
892979

893-
int r = ParseStdioOption(i, js_stdio_option.As<Object>());
894-
if (r < 0)
895-
return r;
980+
int r;
981+
if (!ParseStdioOption(i, js_stdio_option.As<Object>()).To(&r)) {
982+
return Nothing<int>();
983+
}
984+
if (r < 0) {
985+
return Just<int>(r);
986+
}
896987
}
897988

898989
uv_process_options_.stdio = uv_stdio_containers_;
899990
uv_process_options_.stdio_count = stdio_count_;
900991

901-
return 0;
992+
return Just<int>(0);
902993
}
903994

904-
905-
int SyncProcessRunner::ParseStdioOption(int child_fd,
906-
Local<Object> js_stdio_option) {
995+
Maybe<int> SyncProcessRunner::ParseStdioOption(int child_fd,
996+
Local<Object> js_stdio_option) {
907997
Local<Context> context = env()->context();
908-
Local<Value> js_type =
909-
js_stdio_option->Get(context, env()->type_string()).ToLocalChecked();
998+
Local<Value> js_type;
999+
if (!js_stdio_option->Get(context, env()->type_string()).ToLocal(&js_type)) {
1000+
return Nothing<int>();
1001+
}
9101002

9111003
if (js_type->StrictEquals(env()->ignore_string())) {
912-
return AddStdioIgnore(child_fd);
913-
1004+
return Just(AddStdioIgnore(child_fd));
9141005
} else if (js_type->StrictEquals(env()->pipe_string())) {
9151006
Isolate* isolate = env()->isolate();
9161007
Local<String> rs = env()->readable_string();
9171008
Local<String> ws = env()->writable_string();
9181009

919-
bool readable = js_stdio_option->Get(context, rs)
920-
.ToLocalChecked()->BooleanValue(isolate);
921-
bool writable =
922-
js_stdio_option->Get(context, ws)
923-
.ToLocalChecked()->BooleanValue(isolate);
1010+
Local<Value> value;
1011+
if (!js_stdio_option->Get(context, rs).ToLocal(&value)) {
1012+
return Nothing<int>();
1013+
}
1014+
auto readable = value->BooleanValue(isolate);
1015+
1016+
if (!js_stdio_option->Get(context, ws).ToLocal(&value)) {
1017+
return Nothing<int>();
1018+
}
1019+
bool writable = value->BooleanValue(isolate);
9241020

9251021
uv_buf_t buf = uv_buf_init(nullptr, 0);
9261022

9271023
if (readable) {
928-
Local<Value> input =
929-
js_stdio_option->Get(context, env()->input_string()).ToLocalChecked();
1024+
Local<Value> input;
1025+
if (!js_stdio_option->Get(context, env()->input_string())
1026+
.ToLocal(&input)) {
1027+
return Nothing<int>();
1028+
}
9301029
if (Buffer::HasInstance(input)) {
9311030
buf = uv_buf_init(Buffer::Data(input),
9321031
static_cast<unsigned int>(Buffer::Length(input)));
9331032
} else if (!input->IsUndefined() && !input->IsNull()) {
9341033
// Strings, numbers etc. are currently unsupported. It's not possible
9351034
// to create a buffer for them here because there is no way to free
9361035
// them afterwards.
937-
return UV_EINVAL;
1036+
return Just<int>(UV_EINVAL);
9381037
}
9391038
}
9401039

941-
return AddStdioPipe(child_fd, readable, writable, buf);
1040+
return Just(AddStdioPipe(child_fd, readable, writable, buf));
9421041

9431042
} else if (js_type->StrictEquals(env()->inherit_string()) ||
9441043
js_type->StrictEquals(env()->fd_string())) {
945-
int inherit_fd = js_stdio_option->Get(context, env()->fd_string())
946-
.ToLocalChecked()->Int32Value(context).FromJust();
947-
return AddStdioInheritFD(child_fd, inherit_fd);
948-
949-
} else {
950-
UNREACHABLE("invalid child stdio type");
1044+
Local<Value> val;
1045+
int inherit_fd;
1046+
if (!js_stdio_option->Get(context, env()->fd_string()).ToLocal(&val) ||
1047+
!val->Int32Value(context).To(&inherit_fd)) {
1048+
return Nothing<int>();
1049+
}
1050+
return Just(AddStdioInheritFD(child_fd, inherit_fd));
9511051
}
952-
}
9531052

1053+
UNREACHABLE("invalid child stdio type");
1054+
}
9541055

9551056
int SyncProcessRunner::AddStdioIgnore(uint32_t child_fd) {
9561057
CHECK_LT(child_fd, stdio_count_);
@@ -997,11 +1098,6 @@ int SyncProcessRunner::AddStdioInheritFD(uint32_t child_fd, int inherit_fd) {
9971098
return 0;
9981099
}
9991100

1000-
1001-
bool SyncProcessRunner::IsSet(Local<Value> value) {
1002-
return !value->IsUndefined() && !value->IsNull();
1003-
}
1004-
10051101
Maybe<int> SyncProcessRunner::CopyJsString(Local<Value> js_value,
10061102
const char** target) {
10071103
Isolate* isolate = env()->isolate();
@@ -1054,18 +1150,18 @@ Maybe<int> SyncProcessRunner::CopyJsStringArray(Local<Value> js_value,
10541150
// length of all strings, including room for a null terminator after every
10551151
// string. Align strings to cache lines.
10561152
for (uint32_t i = 0; i < length; i++) {
1057-
auto value = js_array->Get(context, i).ToLocalChecked();
1153+
Local<Value> value;
1154+
if (!js_array->Get(context, i).ToLocal(&value)) {
1155+
return Nothing<int>();
1156+
}
10581157

10591158
if (!value->IsString()) {
10601159
Local<String> string;
10611160
if (!value->ToString(env()->isolate()->GetCurrentContext())
1062-
.ToLocal(&string))
1161+
.ToLocal(&string) ||
1162+
js_array->Set(context, i, string).IsNothing()) {
10631163
return Nothing<int>();
1064-
js_array
1065-
->Set(context,
1066-
i,
1067-
string)
1068-
.Check();
1164+
}
10691165
}
10701166

10711167
Maybe<size_t> maybe_size = StringBytes::StorageSize(isolate, value, UTF8);
@@ -1081,7 +1177,10 @@ Maybe<int> SyncProcessRunner::CopyJsStringArray(Local<Value> js_value,
10811177

10821178
for (uint32_t i = 0; i < length; i++) {
10831179
list[i] = buffer + data_offset;
1084-
auto value = js_array->Get(context, i).ToLocalChecked();
1180+
Local<Value> value;
1181+
if (!js_array->Get(context, i).ToLocal(&value)) {
1182+
return Nothing<int>();
1183+
}
10851184
data_offset += StringBytes::Write(isolate,
10861185
buffer + data_offset,
10871186
-1,

Diff for: ‎src/spawn_sync.h

+6-5
Original file line numberDiff line numberDiff line change
@@ -82,7 +82,7 @@ class SyncProcessStdioPipe {
8282
int Start();
8383
void Close();
8484

85-
v8::Local<v8::Object> GetOutputAsBuffer(Environment* env) const;
85+
v8::MaybeLocal<v8::Object> GetOutputAsBuffer(Environment* env) const;
8686

8787
inline bool readable() const;
8888
inline bool writable() const;
@@ -171,12 +171,13 @@ class SyncProcessRunner {
171171
void SetError(int error);
172172
void SetPipeError(int pipe_error);
173173

174-
v8::Local<v8::Object> BuildResultObject();
175-
v8::Local<v8::Array> BuildOutputArray();
174+
v8::MaybeLocal<v8::Object> BuildResultObject();
175+
v8::MaybeLocal<v8::Array> BuildOutputArray();
176176

177177
v8::Maybe<int> ParseOptions(v8::Local<v8::Value> js_value);
178-
int ParseStdioOptions(v8::Local<v8::Value> js_value);
179-
int ParseStdioOption(int child_fd, v8::Local<v8::Object> js_stdio_option);
178+
v8::Maybe<int> ParseStdioOptions(v8::Local<v8::Value> js_value);
179+
v8::Maybe<int> ParseStdioOption(int child_fd,
180+
v8::Local<v8::Object> js_stdio_option);
180181

181182
inline int AddStdioIgnore(uint32_t child_fd);
182183
inline int AddStdioPipe(uint32_t child_fd,

0 commit comments

Comments
 (0)
Please sign in to comment.