@@ -119,7 +119,6 @@ using options_parser::kAllowedInEnvironment;
119
119
using options_parser::kDisallowedInEnvironment ;
120
120
121
121
using v8::Boolean;
122
- using v8::Context;
123
122
using v8::EscapableHandleScope;
124
123
using v8::Exception;
125
124
using v8::Function;
@@ -271,99 +270,111 @@ void Environment::InitializeDiagnostics() {
271
270
#endif
272
271
}
273
272
274
- MaybeLocal<Value> RunBootstrapping (Environment* env) {
275
- CHECK (!env->has_run_bootstrapping_code ());
276
-
277
- EscapableHandleScope scope (env->isolate ());
278
- Isolate* isolate = env->isolate ();
279
- Local<Context> context = env->context ();
280
-
281
-
282
- // Add a reference to the global object
283
- Local<Object> global = context->Global ();
284
- Local<Object> process = env->process_object ();
285
-
286
- // Setting global properties for the bootstrappers to use:
287
- // - global
288
- // Expose the global object as a property on itself
289
- // (Allows you to set stuff on `global` from anywhere in JavaScript.)
290
- global->Set (context, FIXED_ONE_BYTE_STRING (env->isolate (), " global" ), global)
291
- .Check ();
292
-
273
+ MaybeLocal<Value> Environment::BootstrapInternalLoaders () {
274
+ EscapableHandleScope scope (isolate_);
293
275
294
276
// Create binding loaders
295
277
std::vector<Local<String>> loaders_params = {
296
- env-> process_string (),
297
- FIXED_ONE_BYTE_STRING (isolate , " getLinkedBinding" ),
298
- FIXED_ONE_BYTE_STRING (isolate , " getInternalBinding" ),
299
- env-> primordials_string ()};
278
+ process_string (),
279
+ FIXED_ONE_BYTE_STRING (isolate_ , " getLinkedBinding" ),
280
+ FIXED_ONE_BYTE_STRING (isolate_ , " getInternalBinding" ),
281
+ primordials_string ()};
300
282
std::vector<Local<Value>> loaders_args = {
301
- process ,
302
- env-> NewFunctionTemplate (binding::GetLinkedBinding)
303
- ->GetFunction (context)
283
+ process_object () ,
284
+ NewFunctionTemplate (binding::GetLinkedBinding)
285
+ ->GetFunction (context () )
304
286
.ToLocalChecked (),
305
- env-> NewFunctionTemplate (binding::GetInternalBinding)
306
- ->GetFunction (context)
287
+ NewFunctionTemplate (binding::GetInternalBinding)
288
+ ->GetFunction (context () )
307
289
.ToLocalChecked (),
308
- env-> primordials ()};
290
+ primordials ()};
309
291
310
292
// Bootstrap internal loaders
311
- MaybeLocal<Value> loader_exports = ExecuteBootstrapper (
312
- env, " internal/bootstrap/loaders" , &loaders_params, &loaders_args);
313
- if (loader_exports.IsEmpty ()) {
293
+ Local<Value> loader_exports;
294
+ if (!ExecuteBootstrapper (
295
+ this , " internal/bootstrap/loaders" , &loaders_params, &loaders_args)
296
+ .ToLocal (&loader_exports)) {
314
297
return MaybeLocal<Value>();
315
298
}
316
-
317
- Local<Object> loader_exports_obj =
318
- loader_exports.ToLocalChecked ().As <Object>();
299
+ CHECK (loader_exports->IsObject ());
300
+ Local<Object> loader_exports_obj = loader_exports.As <Object>();
319
301
Local<Value> internal_binding_loader =
320
- loader_exports_obj->Get (context, env-> internal_binding_string ())
302
+ loader_exports_obj->Get (context (), internal_binding_string ())
321
303
.ToLocalChecked ();
322
- env-> set_internal_binding_loader (internal_binding_loader. As <Function> ());
323
-
304
+ CHECK (internal_binding_loader-> IsFunction ());
305
+ set_internal_binding_loader (internal_binding_loader. As <Function>());
324
306
Local<Value> require =
325
- loader_exports_obj->Get (context, env->require_string ()).ToLocalChecked ();
326
- env->set_native_module_require (require.As <Function>());
307
+ loader_exports_obj->Get (context (), require_string ()).ToLocalChecked ();
308
+ CHECK (require->IsFunction ());
309
+ set_native_module_require (require.As <Function>());
310
+
311
+ return scope.Escape (loader_exports);
312
+ }
313
+
314
+ MaybeLocal<Value> Environment::BootstrapNode () {
315
+ EscapableHandleScope scope (isolate_);
316
+
317
+ Local<Object> global = context ()->Global ();
318
+ // TODO(joyeecheung): this can be done in JS land now.
319
+ global->Set (context (), FIXED_ONE_BYTE_STRING (isolate_, " global" ), global)
320
+ .Check ();
327
321
328
322
// process, require, internalBinding, isMainThread,
329
323
// ownsProcessState, primordials
330
324
std::vector<Local<String>> node_params = {
331
- env-> process_string (),
332
- env-> require_string (),
333
- env-> internal_binding_string (),
334
- FIXED_ONE_BYTE_STRING (isolate , " isMainThread" ),
335
- FIXED_ONE_BYTE_STRING (isolate , " ownsProcessState" ),
336
- env-> primordials_string ()};
325
+ process_string (),
326
+ require_string (),
327
+ internal_binding_string (),
328
+ FIXED_ONE_BYTE_STRING (isolate_ , " isMainThread" ),
329
+ FIXED_ONE_BYTE_STRING (isolate_ , " ownsProcessState" ),
330
+ primordials_string ()};
337
331
std::vector<Local<Value>> node_args = {
338
- process ,
339
- require ,
340
- internal_binding_loader,
341
- Boolean::New (isolate, env-> is_main_thread ()),
342
- Boolean::New (isolate, env-> owns_process_state ()),
343
- env-> primordials ()};
332
+ process_object () ,
333
+ native_module_require () ,
334
+ internal_binding_loader () ,
335
+ Boolean::New (isolate_, is_main_thread ()),
336
+ Boolean::New (isolate_, owns_process_state ()),
337
+ primordials ()};
344
338
345
339
MaybeLocal<Value> result = ExecuteBootstrapper (
346
- env , " internal/bootstrap/node" , &node_params, &node_args);
340
+ this , " internal/bootstrap/node" , &node_params, &node_args);
347
341
348
342
Local<Object> env_var_proxy;
349
- if (!CreateEnvVarProxy (context, isolate, env-> as_callback_data ())
343
+ if (!CreateEnvVarProxy (context (), isolate_, as_callback_data ())
350
344
.ToLocal (&env_var_proxy) ||
351
- process
352
- ->Set (env->context (),
353
- FIXED_ONE_BYTE_STRING (env->isolate (), " env" ),
354
- env_var_proxy)
355
- .IsNothing ())
345
+ process_object ()
346
+ ->Set (
347
+ context (), FIXED_ONE_BYTE_STRING (isolate_, " env" ), env_var_proxy)
348
+ .IsNothing ()) {
349
+ return MaybeLocal<Value>();
350
+ }
351
+
352
+ return scope.EscapeMaybe (result);
353
+ }
354
+
355
+ MaybeLocal<Value> Environment::RunBootstrapping () {
356
+ EscapableHandleScope scope (isolate_);
357
+
358
+ CHECK (!has_run_bootstrapping_code ());
359
+
360
+ if (BootstrapInternalLoaders ().IsEmpty ()) {
361
+ return MaybeLocal<Value>();
362
+ }
363
+
364
+ Local<Value> result;
365
+ if (!BootstrapNode ().ToLocal (&result)) {
356
366
return MaybeLocal<Value>();
367
+ }
357
368
358
369
// Make sure that no request or handle is created during bootstrap -
359
370
// if necessary those should be done in pre-execution.
360
371
// TODO(joyeecheung): print handles/requests before aborting
361
- CHECK (env-> req_wrap_queue ()->IsEmpty ());
362
- CHECK (env-> handle_wrap_queue ()->IsEmpty ());
372
+ CHECK (req_wrap_queue ()->IsEmpty ());
373
+ CHECK (handle_wrap_queue ()->IsEmpty ());
363
374
364
- env-> set_has_run_bootstrapping_code (true );
375
+ set_has_run_bootstrapping_code (true );
365
376
366
- return scope.EscapeMaybe (result);
377
+ return scope.Escape (result);
367
378
}
368
379
369
380
void MarkBootstrapComplete (const FunctionCallbackInfo<Value>& args) {
0 commit comments