src: simplify code, remove NodeInstanceData

NodeInstanceData is not used meaningfully and makes the initialization
logic harder to follow.  Let's remove it and delete 100 lines of code
in one fell swoop.

PR-URL: #9224
Reviewed-By: James M Snell <[email protected]>

Author: bnoordhuis

src/node.cc

@@ -4369,10 +4369,9 @@ void FreeEnvironment(Environment* env) {
 }
 
 
-// Entry point for new node instances, also called directly for the main
-// node instance.
-static void StartNodeInstance(void* arg) {
-  NodeInstanceData* instance_data = static_cast<NodeInstanceData*>(arg);
+inline int Start(uv_loop_t* event_loop,
+                 int argc, const char* const* argv,
+                 int exec_argc, const char* const* exec_argv) {
   Isolate::CreateParams params;
   ArrayBufferAllocator array_buffer_allocator;
   params.array_buffer_allocator = &array_buffer_allocator;
@@ -4383,39 +4382,32 @@ static void StartNodeInstance(void* arg) {
 
   {
     Mutex::ScopedLock scoped_lock(node_isolate_mutex);
-    if (instance_data->is_main()) {
-      CHECK_EQ(node_isolate, nullptr);
-      node_isolate = isolate;
-    }
+    CHECK_EQ(node_isolate, nullptr);
+    node_isolate = isolate;
   }
 
   if (track_heap_objects) {
     isolate->GetHeapProfiler()->StartTrackingHeapObjects(true);
   }
 
+  int exit_code;
   {
     Locker locker(isolate);
     Isolate::Scope isolate_scope(isolate);
     HandleScope handle_scope(isolate);
-    IsolateData isolate_data(isolate, instance_data->event_loop(),
+    IsolateData isolate_data(isolate, event_loop,
                              array_buffer_allocator.zero_fill_field());
     Local<Context> context = Context::New(isolate);
     Context::Scope context_scope(context);
     Environment env(&isolate_data, context);
-    env.Start(instance_data->argc(),
-              instance_data->argv(),
-              instance_data->exec_argc(),
-              instance_data->exec_argv(),
-              v8_is_profiling);
+    env.Start(argc, argv, exec_argc, exec_argv, v8_is_profiling);
 
     isolate->SetAbortOnUncaughtExceptionCallback(
         ShouldAbortOnUncaughtException);
 
     // Start debug agent when argv has --debug
-    if (instance_data->use_debug_agent()) {
-      const char* path = instance_data->argc() > 1
-                         ? instance_data->argv()[1]
-                         : nullptr;
+    if (use_debug_agent) {
+      const char* path = argc > 1 ? argv[1] : nullptr;
       StartDebug(&env, path, debug_wait_connect);
       if (use_inspector && !debugger_running) {
         exit(12);
@@ -4430,7 +4422,7 @@ static void StartNodeInstance(void* arg) {
     env.set_trace_sync_io(trace_sync_io);
 
     // Enable debugger
-    if (instance_data->use_debug_agent())
+    if (use_debug_agent)
       EnableDebug(&env);
 
     {
@@ -4455,9 +4447,7 @@ static void StartNodeInstance(void* arg) {
 
     env.set_trace_sync_io(false);
 
-    int exit_code = EmitExit(&env);
-    if (instance_data->is_main())
-      instance_data->set_exit_code(exit_code);
+    exit_code = EmitExit(&env);
     RunAtExit(&env);
 
     WaitForInspectorDisconnect(&env);
@@ -4475,6 +4465,8 @@ static void StartNodeInstance(void* arg) {
   CHECK_NE(isolate, nullptr);
   isolate->Dispose();
   isolate = nullptr;
+
+  return exit_code;
 }
 
 int Start(int argc, char** argv) {
@@ -4505,19 +4497,8 @@ int Start(int argc, char** argv) {
   v8_platform.Initialize(v8_thread_pool_size);
   V8::Initialize();
   v8_initialized = true;
-
-  int exit_code = 1;
-  {
-    NodeInstanceData instance_data(NodeInstanceType::MAIN,
-                                   uv_default_loop(),
-                                   argc,
-                                   const_cast<const char**>(argv),
-                                   exec_argc,
-                                   exec_argv,
-                                   use_debug_agent);
-    StartNodeInstance(&instance_data);
-    exit_code = instance_data.exit_code();
-  }
+  const int exit_code =
+      Start(uv_default_loop(), argc, argv, exec_argc, exec_argv);
   v8_initialized = false;
   V8::Dispose();
 

src/node_internals.h

@@ -179,87 +179,6 @@ class ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
 // by clearing all callbacks that could handle the error.
 void ClearFatalExceptionHandlers(Environment* env);
 
-enum NodeInstanceType { MAIN, WORKER, REMOTE_DEBUG_SERVER };
-
-class NodeInstanceData {
- public:
-  NodeInstanceData(NodeInstanceType node_instance_type,
-                   uv_loop_t* event_loop,
-                   int argc,
-                   const char** argv,
-                   int exec_argc,
-                   const char** exec_argv,
-                   bool use_debug_agent_flag)
-      : node_instance_type_(node_instance_type),
-        exit_code_(1),
-        event_loop_(event_loop),
-        argc_(argc),
-        argv_(argv),
-        exec_argc_(exec_argc),
-        exec_argv_(exec_argv),
-        use_debug_agent_flag_(use_debug_agent_flag) {
-    CHECK_NE(event_loop_, nullptr);
-  }
-
-  uv_loop_t* event_loop() const {
-    return event_loop_;
-  }
-
-  int exit_code() {
-    CHECK(is_main());
-    return exit_code_;
-  }
-
-  void set_exit_code(int exit_code) {
-    CHECK(is_main());
-    exit_code_ = exit_code;
-  }
-
-  bool is_main() {
-    return node_instance_type_ == MAIN;
-  }
-
-  bool is_worker() {
-    return node_instance_type_ == WORKER;
-  }
-
-  bool is_remote_debug_server() {
-    return node_instance_type_ == REMOTE_DEBUG_SERVER;
-  }
-
-  int argc() {
-    return argc_;
-  }
-
-  const char** argv() {
-    return argv_;
-  }
-
-  int exec_argc() {
-    return exec_argc_;
-  }
-
-  const char** exec_argv() {
-    return exec_argv_;
-  }
-
-  bool use_debug_agent() {
-    return is_main() && use_debug_agent_flag_;
-  }
-
- private:
-  const NodeInstanceType node_instance_type_;
-  int exit_code_;
-  uv_loop_t* const event_loop_;
-  const int argc_;
-  const char** argv_;
-  const int exec_argc_;
-  const char** exec_argv_;
-  const bool use_debug_agent_flag_;
-
-  DISALLOW_COPY_AND_ASSIGN(NodeInstanceData);
-};
-
 namespace Buffer {
 v8::MaybeLocal<v8::Object> Copy(Environment* env, const char* data, size_t len);
 v8::MaybeLocal<v8::Object> New(Environment* env, size_t size);