bootstrap: use different scripts to setup different configurations

This patch splits the handling of `isMainThread` and
`ownsProcessState` from conditionals in
`lib/internal/bootstrap/node.js` into different scripts under
`lib/internal/bootstrap/switches/`, and call them accordingly
from C++ after `node.js` is run.

This:

- Creates a common denominator of the main thread and the worker
  thread bootstrap that can be snapshotted and shared by
  both.
- Makes it possible to override the configurations on-the-fly.

PR-URL: https://github.com/nodejs/node/pull/30862
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>

1 files changed, 40 insertions, 7 deletions

diff --git a/src/node.cc b/src/node.cc
index d8da205b681..f5ae0159d27 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -128,7 +128,6 @@ namespace node {
 
 using native_module::NativeModuleEnv;
 
-using v8::Boolean;
 using v8::EscapableHandleScope;
 using v8::Function;
 using v8::FunctionCallbackInfo;
@@ -297,26 +296,60 @@ MaybeLocal<Value> Environment::BootstrapNode() {
   global->Set(context(), FIXED_ONE_BYTE_STRING(isolate_, "global"), global)
       .Check();
 
-  // process, require, internalBinding, isMainThread,
-  // ownsProcessState, primordials
+  // process, require, internalBinding, primordials
   std::vector<Local<String>> node_params = {
       process_string(),
       require_string(),
       internal_binding_string(),
-      FIXED_ONE_BYTE_STRING(isolate_, "isMainThread"),
-      FIXED_ONE_BYTE_STRING(isolate_, "ownsProcessState"),
       primordials_string()};
   std::vector<Local<Value>> node_args = {
       process_object(),
       native_module_require(),
       internal_binding_loader(),
-      Boolean::New(isolate_, is_main_thread()),
-      Boolean::New(isolate_, owns_process_state()),
       primordials()};
 
   MaybeLocal<Value> result = ExecuteBootstrapper(
       this, "internal/bootstrap/node", &node_params, &node_args);
 
+  if (result.IsEmpty()) {
+    return scope.EscapeMaybe(result);
+  }
+
+  if (is_main_thread()) {
+    result = ExecuteBootstrapper(this,
+                                 "internal/bootstrap/switches/is_main_thread",
+                                 &node_params,
+                                 &node_args);
+  } else {
+    result =
+        ExecuteBootstrapper(this,
+                            "internal/bootstrap/switches/is_not_main_thread",
+                            &node_params,
+                            &node_args);
+  }
+
+  if (result.IsEmpty()) {
+    return scope.EscapeMaybe(result);
+  }
+
+  if (owns_process_state()) {
+    result = ExecuteBootstrapper(
+        this,
+        "internal/bootstrap/switches/does_own_process_state",
+        &node_params,
+        &node_args);
+  } else {
+    result = ExecuteBootstrapper(
+        this,
+        "internal/bootstrap/switches/does_not_own_process_state",
+        &node_params,
+        &node_args);
+  }
+
+  if (result.IsEmpty()) {
+    return scope.EscapeMaybe(result);
+  }
+
   Local<Object> env_var_proxy;
   if (!CreateEnvVarProxy(context(), isolate_, as_callback_data())
            .ToLocal(&env_var_proxy) ||