Skip to content

Commit d096c49

Browse files
targostargos
committed
fixup! add using statements
1 parent 96fd305 commit d096c49

File tree

2 files changed

+60
-56
lines changed

2 files changed

+60
-56
lines changed

‎src/spawn_sync.cc

+41-40
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,11 @@ using v8::FunctionCallbackInfo;
3737
using v8::HandleScope;
3838
using v8::Integer;
3939
using v8::Isolate;
40+
using v8::Just;
4041
using v8::Local;
42+
using v8::Maybe;
43+
using v8::MaybeLocal;
44+
using v8::Nothing;
4145
using v8::Null;
4246
using v8::Number;
4347
using v8::Object;
@@ -431,22 +435,21 @@ Environment* SyncProcessRunner::env() const {
431435
return env_;
432436
}
433437

434-
v8::MaybeLocal<Object> SyncProcessRunner::Run(Local<Value> options) {
438+
MaybeLocal<Object> SyncProcessRunner::Run(Local<Value> options) {
435439
EscapableHandleScope scope(env()->isolate());
436440

437441
CHECK_EQ(lifecycle_, kUninitialized);
438442

439-
v8::Maybe<bool> r = TryInitializeAndRunLoop(options);
443+
Maybe<bool> r = TryInitializeAndRunLoop(options);
440444
CloseHandlesAndDeleteLoop();
441-
if (r.IsNothing()) return v8::MaybeLocal<Object>();
445+
if (r.IsNothing()) return MaybeLocal<Object>();
442446

443447
Local<Object> result = BuildResultObject();
444448

445449
return scope.Escape(result);
446450
}
447451

448-
v8::Maybe<bool> SyncProcessRunner::TryInitializeAndRunLoop(
449-
Local<Value> options) {
452+
Maybe<bool> SyncProcessRunner::TryInitializeAndRunLoop(Local<Value> options) {
450453
int r;
451454

452455
// There is no recovery from failure inside TryInitializeAndRunLoop - the
@@ -457,21 +460,21 @@ v8::Maybe<bool> SyncProcessRunner::TryInitializeAndRunLoop(
457460
uv_loop_ = new uv_loop_t;
458461
if (uv_loop_ == nullptr) {
459462
SetError(UV_ENOMEM);
460-
return v8::Just(false);
463+
return Just(false);
461464
}
462465
CHECK_EQ(uv_loop_init(uv_loop_), 0);
463466

464-
if (!ParseOptions(options).To(&r)) return v8::Nothing<bool>();
467+
if (!ParseOptions(options).To(&r)) return Nothing<bool>();
465468
if (r < 0) {
466469
SetError(r);
467-
return v8::Just(false);
470+
return Just(false);
468471
}
469472

470473
if (timeout_ > 0) {
471474
r = uv_timer_init(uv_loop_, &uv_timer_);
472475
if (r < 0) {
473476
SetError(r);
474-
return v8::Just(false);
477+
return Just(false);
475478
}
476479

477480
uv_unref(reinterpret_cast<uv_handle_t*>(&uv_timer_));
@@ -486,15 +489,15 @@ v8::Maybe<bool> SyncProcessRunner::TryInitializeAndRunLoop(
486489
r = uv_timer_start(&uv_timer_, KillTimerCallback, timeout_, 0);
487490
if (r < 0) {
488491
SetError(r);
489-
return v8::Just(false);
492+
return Just(false);
490493
}
491494
}
492495

493496
uv_process_options_.exit_cb = ExitCallback;
494497
r = uv_spawn(uv_loop_, &uv_process_, &uv_process_options_);
495498
if (r < 0) {
496499
SetError(r);
497-
return v8::Just(false);
500+
return Just(false);
498501
}
499502
uv_process_.data = this;
500503

@@ -504,7 +507,7 @@ v8::Maybe<bool> SyncProcessRunner::TryInitializeAndRunLoop(
504507
r = h->Start();
505508
if (r < 0) {
506509
SetPipeError(r);
507-
return v8::Just(false);
510+
return Just(false);
508511
}
509512
}
510513
}
@@ -516,7 +519,7 @@ v8::Maybe<bool> SyncProcessRunner::TryInitializeAndRunLoop(
516519

517520
// If we get here the process should have exited.
518521
CHECK_GE(exit_status_, 0);
519-
return v8::Just(true);
522+
return Just(true);
520523
}
521524

522525

@@ -738,42 +741,41 @@ Local<Array> SyncProcessRunner::BuildOutputArray() {
738741
return scope.Escape(js_output);
739742
}
740743

741-
v8::Maybe<int> SyncProcessRunner::ParseOptions(Local<Value> js_value) {
744+
Maybe<int> SyncProcessRunner::ParseOptions(Local<Value> js_value) {
742745
HandleScope scope(env()->isolate());
743746
int r;
744747

745-
if (!js_value->IsObject()) return v8::Just<int>(UV_EINVAL);
748+
if (!js_value->IsObject()) return Just<int>(UV_EINVAL);
746749

747750
Local<Context> context = env()->context();
748751
Local<Object> js_options = js_value.As<Object>();
749752

750753
Local<Value> js_file =
751754
js_options->Get(context, env()->file_string()).ToLocalChecked();
752-
if (!CopyJsString(js_file, &file_buffer_).To(&r)) return v8::Nothing<int>();
753-
if (r < 0) return v8::Just(r);
755+
if (!CopyJsString(js_file, &file_buffer_).To(&r)) return Nothing<int>();
756+
if (r < 0) return Just(r);
754757
uv_process_options_.file = file_buffer_;
755758

756759
Local<Value> js_args =
757760
js_options->Get(context, env()->args_string()).ToLocalChecked();
758-
if (!CopyJsStringArray(js_args, &args_buffer_).To(&r))
759-
return v8::Nothing<int>();
760-
if (r < 0) return v8::Just(r);
761+
if (!CopyJsStringArray(js_args, &args_buffer_).To(&r)) return Nothing<int>();
762+
if (r < 0) return Just(r);
761763
uv_process_options_.args = reinterpret_cast<char**>(args_buffer_);
762764

763765
Local<Value> js_cwd =
764766
js_options->Get(context, env()->cwd_string()).ToLocalChecked();
765767
if (IsSet(js_cwd)) {
766-
if (!CopyJsString(js_cwd, &cwd_buffer_).To(&r)) return v8::Nothing<int>();
767-
if (r < 0) return v8::Just(r);
768+
if (!CopyJsString(js_cwd, &cwd_buffer_).To(&r)) return Nothing<int>();
769+
if (r < 0) return Just(r);
768770
uv_process_options_.cwd = cwd_buffer_;
769771
}
770772

771773
Local<Value> js_env_pairs =
772774
js_options->Get(context, env()->env_pairs_string()).ToLocalChecked();
773775
if (IsSet(js_env_pairs)) {
774776
if (!CopyJsStringArray(js_env_pairs, &env_buffer_).To(&r))
775-
return v8::Nothing<int>();
776-
if (r < 0) return v8::Just(r);
777+
return Nothing<int>();
778+
if (r < 0) return Just(r);
777779

778780
uv_process_options_.env = reinterpret_cast<char**>(env_buffer_);
779781
}
@@ -837,9 +839,9 @@ v8::Maybe<int> SyncProcessRunner::ParseOptions(Local<Value> js_value) {
837839
Local<Value> js_stdio =
838840
js_options->Get(context, env()->stdio_string()).ToLocalChecked();
839841
r = ParseStdioOptions(js_stdio);
840-
if (r < 0) return v8::Just(r);
842+
if (r < 0) return Just(r);
841843

842-
return v8::Just(0);
844+
return Just(0);
843845
}
844846

845847

@@ -979,8 +981,8 @@ bool SyncProcessRunner::IsSet(Local<Value> value) {
979981
return !value->IsUndefined() && !value->IsNull();
980982
}
981983

982-
v8::Maybe<int> SyncProcessRunner::CopyJsString(Local<Value> js_value,
983-
const char** target) {
984+
Maybe<int> SyncProcessRunner::CopyJsString(Local<Value> js_value,
985+
const char** target) {
984986
Isolate* isolate = env()->isolate();
985987
Local<String> js_string;
986988
size_t size, written;
@@ -990,11 +992,11 @@ v8::Maybe<int> SyncProcessRunner::CopyJsString(Local<Value> js_value,
990992
js_string = js_value.As<String>();
991993
else if (!js_value->ToString(env()->isolate()->GetCurrentContext())
992994
.ToLocal(&js_string))
993-
return v8::Nothing<int>();
995+
return Nothing<int>();
994996

995997
// Include space for null terminator byte.
996998
if (!StringBytes::StorageSize(isolate, js_string, UTF8).To(&size))
997-
return v8::Nothing<int>();
999+
return Nothing<int>();
9981000
size += 1;
9991001

10001002
buffer = new char[size];
@@ -1003,19 +1005,19 @@ v8::Maybe<int> SyncProcessRunner::CopyJsString(Local<Value> js_value,
10031005
buffer[written] = '\0';
10041006

10051007
*target = buffer;
1006-
return v8::Just(0);
1008+
return Just(0);
10071009
}
10081010

1009-
v8::Maybe<int> SyncProcessRunner::CopyJsStringArray(Local<Value> js_value,
1010-
char** target) {
1011+
Maybe<int> SyncProcessRunner::CopyJsStringArray(Local<Value> js_value,
1012+
char** target) {
10111013
Isolate* isolate = env()->isolate();
10121014
Local<Array> js_array;
10131015
uint32_t length;
10141016
size_t list_size, data_size, data_offset;
10151017
char** list;
10161018
char* buffer;
10171019

1018-
if (!js_value->IsArray()) return v8::Just<int>(UV_EINVAL);
1020+
if (!js_value->IsArray()) return Just<int>(UV_EINVAL);
10191021

10201022
Local<Context> context = env()->context();
10211023
js_array = js_value.As<Array>()->Clone().As<Array>();
@@ -1034,10 +1036,10 @@ v8::Maybe<int> SyncProcessRunner::CopyJsStringArray(Local<Value> js_value,
10341036
auto value = js_array->Get(context, i).ToLocalChecked();
10351037

10361038
if (!value->IsString()) {
1037-
v8::Local<String> string;
1039+
Local<String> string;
10381040
if (!value->ToString(env()->isolate()->GetCurrentContext())
10391041
.ToLocal(&string))
1040-
return v8::Nothing<int>();
1042+
return Nothing<int>();
10411043
js_array
10421044
->Set(context,
10431045
i,
@@ -1046,9 +1048,8 @@ v8::Maybe<int> SyncProcessRunner::CopyJsStringArray(Local<Value> js_value,
10461048
.FromJust();
10471049
}
10481050

1049-
v8::Maybe<size_t> maybe_size =
1050-
StringBytes::StorageSize(isolate, value, UTF8);
1051-
if (maybe_size.IsNothing()) return v8::Nothing<int>();
1051+
Maybe<size_t> maybe_size = StringBytes::StorageSize(isolate, value, UTF8);
1052+
if (maybe_size.IsNothing()) return Nothing<int>();
10521053
data_size += maybe_size.FromJust() + 1;
10531054
data_size = ROUND_UP(data_size, sizeof(void*));
10541055
}
@@ -1073,7 +1074,7 @@ v8::Maybe<int> SyncProcessRunner::CopyJsStringArray(Local<Value> js_value,
10731074
list[length] = nullptr;
10741075

10751076
*target = buffer;
1076-
return v8::Just(0);
1077+
return Just(0);
10771078
}
10781079

10791080

‎src/string_bytes.cc

+19-16
Original file line numberDiff line numberDiff line change
@@ -41,8 +41,11 @@ namespace node {
4141

4242
using v8::HandleScope;
4343
using v8::Isolate;
44+
using v8::Just;
4445
using v8::Local;
46+
using v8::Maybe;
4547
using v8::MaybeLocal;
48+
using v8::Nothing;
4649
using v8::String;
4750
using v8::Value;
4851

@@ -399,20 +402,20 @@ bool StringBytes::IsValidString(Local<String> string,
399402
// Quick and dirty size calculation
400403
// Will always be at least big enough, but may have some extra
401404
// UTF8 can be as much as 3x the size, Base64 can have 1-2 extra bytes
402-
v8::Maybe<size_t> StringBytes::StorageSize(Isolate* isolate,
403-
Local<Value> val,
404-
enum encoding encoding) {
405+
Maybe<size_t> StringBytes::StorageSize(Isolate* isolate,
406+
Local<Value> val,
407+
enum encoding encoding) {
405408
HandleScope scope(isolate);
406409
size_t data_size = 0;
407410
bool is_buffer = Buffer::HasInstance(val);
408411

409412
if (is_buffer && (encoding == BUFFER || encoding == LATIN1)) {
410-
return v8::Just(Buffer::Length(val));
413+
return Just(Buffer::Length(val));
411414
}
412415

413416
Local<String> str;
414417
if (!val->ToString(isolate->GetCurrentContext()).ToLocal(&str))
415-
return v8::Nothing<size_t>();
418+
return Nothing<size_t>();
416419

417420
switch (encoding) {
418421
case ASCII:
@@ -446,40 +449,40 @@ v8::Maybe<size_t> StringBytes::StorageSize(Isolate* isolate,
446449
break;
447450
}
448451

449-
return v8::Just(data_size);
452+
return Just(data_size);
450453
}
451454

452-
v8::Maybe<size_t> StringBytes::Size(Isolate* isolate,
453-
Local<Value> val,
454-
enum encoding encoding) {
455+
Maybe<size_t> StringBytes::Size(Isolate* isolate,
456+
Local<Value> val,
457+
enum encoding encoding) {
455458
HandleScope scope(isolate);
456459

457460
if (Buffer::HasInstance(val) && (encoding == BUFFER || encoding == LATIN1))
458-
return v8::Just(Buffer::Length(val));
461+
return Just(Buffer::Length(val));
459462

460463
Local<String> str;
461464
if (!val->ToString(isolate->GetCurrentContext()).ToLocal(&str))
462-
return v8::Nothing<size_t>();
465+
return Nothing<size_t>();
463466

464467
switch (encoding) {
465468
case ASCII:
466469
case LATIN1:
467-
return v8::Just<size_t>(str->Length());
470+
return Just<size_t>(str->Length());
468471

469472
case BUFFER:
470473
case UTF8:
471-
return v8::Just<size_t>(str->Utf8Length(isolate));
474+
return Just<size_t>(str->Utf8Length(isolate));
472475

473476
case UCS2:
474-
return v8::Just(str->Length() * sizeof(uint16_t));
477+
return Just(str->Length() * sizeof(uint16_t));
475478

476479
case BASE64: {
477480
String::Value value(isolate, str);
478-
return v8::Just(base64_decoded_size(*value, value.length()));
481+
return Just(base64_decoded_size(*value, value.length()));
479482
}
480483

481484
case HEX:
482-
return v8::Just<size_t>(str->Length() / 2);
485+
return Just<size_t>(str->Length() / 2);
483486
}
484487

485488
UNREACHABLE();

0 commit comments

Comments
 (0)