src: allow creating NodeMainInstance that does not own the isolate

Allows instantiating a NodeMainInstance with an isolate
whose initialization and disposal are controlled by the caller.

PR-URL: https://github.com/nodejs/node/pull/27321
Refs: https://github.com/nodejs/node/issues/17058
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>

1 files changed, 54 insertions, 13 deletions

diff --git a/src/node_main_instance.cc b/src/node_main_instance.cc
index 6ef992d006..4b05149b23 100644
--- a/src/node_main_instance.cc
+++ b/src/node_main_instance.cc
@@ -12,30 +12,70 @@ using v8::Local;
 using v8::Locker;
 using v8::SealHandleScope;
 
-NodeMainInstance::NodeMainInstance(uv_loop_t* event_loop,
+NodeMainInstance::NodeMainInstance(Isolate* isolate,
+                                   uv_loop_t* event_loop,
+                                   MultiIsolatePlatform* platform,
+                                   const std::vector<std::string>& args,
+                                   const std::vector<std::string>& exec_args)
+    : args_(args),
+      exec_args_(exec_args),
+      array_buffer_allocator_(nullptr),
+      isolate_(isolate),
+      platform_(platform),
+      isolate_data_(nullptr),
+      owns_isolate_(false) {
+  isolate_data_.reset(new IsolateData(isolate_, event_loop, platform, nullptr));
+  SetIsolateUpForNode(isolate_, IsolateSettingCategories::kMisc);
+}
+
+NodeMainInstance* NodeMainInstance::Create(
+    Isolate* isolate,
+    uv_loop_t* event_loop,
+    MultiIsolatePlatform* platform,
+    const std::vector<std::string>& args,
+    const std::vector<std::string>& exec_args) {
+  return new NodeMainInstance(isolate, event_loop, platform, args, exec_args);
+}
+
+NodeMainInstance::NodeMainInstance(Isolate::CreateParams* params,
+                                   uv_loop_t* event_loop,
+                                   MultiIsolatePlatform* platform,
                                    const std::vector<std::string>& args,
                                    const std::vector<std::string>& exec_args)
     : args_(args),
       exec_args_(exec_args),
       array_buffer_allocator_(ArrayBufferAllocator::Create()),
       isolate_(nullptr),
-      isolate_data_(nullptr) {
-  // TODO(joyeecheung): when we implement snapshot integration this needs to
-  // set params.external_references.
-  Isolate::CreateParams params;
-  params.array_buffer_allocator = array_buffer_allocator_.get();
-  isolate_ =
-      NewIsolate(&params, event_loop, per_process::v8_platform.Platform());
+      platform_(platform),
+      isolate_data_(nullptr),
+      owns_isolate_(true) {
+  params->array_buffer_allocator = array_buffer_allocator_.get();
+  isolate_ = Isolate::Allocate();
   CHECK_NOT_NULL(isolate_);
-  isolate_data_.reset(CreateIsolateData(isolate_,
-                                        event_loop,
-                                        per_process::v8_platform.Platform(),
-                                        array_buffer_allocator_.get()));
+  // Register the isolate on the platform before the isolate gets initialized,
+  // so that the isolate can access the platform during initialization.
+  platform->RegisterIsolate(isolate_, event_loop);
+  SetIsolateCreateParamsForNode(params);
+  Isolate::Initialize(isolate_, *params);
+
+  isolate_data_.reset(new IsolateData(
+      isolate_, event_loop, platform, array_buffer_allocator_.get()));
+  SetIsolateUpForNode(isolate_, IsolateSettingCategories::kMisc);
+  SetIsolateUpForNode(isolate_, IsolateSettingCategories::kErrorHandlers);
+}
+
+void NodeMainInstance::Dispose() {
+  CHECK(!owns_isolate_);
+  platform_->DrainTasks(isolate_);
+  delete this;
 }
 
 NodeMainInstance::~NodeMainInstance() {
+  if (!owns_isolate_) {
+    return;
+  }
   isolate_->Dispose();
-  per_process::v8_platform.Platform()->UnregisterIsolate(isolate_);
+  platform_->UnregisterIsolate(isolate_);
 }
 
 int NodeMainInstance::Run() {
@@ -120,6 +160,7 @@ std::unique_ptr<Environment> NodeMainInstance::CreateMainEnvironment(
   }
 
   Local<Context> context = NewContext(isolate_);
+  CHECK(!context.IsEmpty());
   Context::Scope context_scope(context);
 
   std::unique_ptr<Environment> env = std::make_unique<Environment>(