src: support (de)serialization of DOMException

Author: jazelly

lib/internal/per_context/domexception.js

@@ -13,6 +13,9 @@ const {
   TypeError,
 } = primordials;
 
+/* eslint-disable no-undef */
+const isDomException = privateSymbols?.is_dom_exception;
+
 function throwInvalidThisError(Base, type) {
   const err = new Base();
   const key = 'ERR_INVALID_THIS';
@@ -52,6 +55,10 @@ class DOMException {
   constructor(message = '', options = 'Error') {
     ErrorCaptureStackTrace(this);
 
+    if (isDomException) {
+      this[isDomException] = true;
+    }
+
     if (options && typeof options === 'object') {
       const { name } = options;
       internalsMap.set(this, {

src/api/environment.cc

@@ -1,4 +1,5 @@
 #include <cstdlib>
+#include "env_properties.h"
 #include "node.h"
 #include "node_builtins.h"
 #include "node_context_data.h"
@@ -599,7 +600,8 @@ std::unique_ptr<MultiIsolatePlatform> MultiIsolatePlatform::Create(
                                         page_allocator);
 }
 
-MaybeLocal<Object> GetPerContextExports(Local<Context> context) {
+MaybeLocal<Object> GetPerContextExports(Local<Context> context,
+                                        IsolateData* isolate_data) {
   Isolate* isolate = context->GetIsolate();
   EscapableHandleScope handle_scope(isolate);
 
@@ -615,20 +617,22 @@ MaybeLocal<Object> GetPerContextExports(Local<Context> context) {
 
   Local<Object> exports = Object::New(isolate);
   if (context->Global()->SetPrivate(context, key, exports).IsNothing() ||
-      InitializePrimordials(context).IsNothing())
+      InitializePrimordials(context, isolate_data).IsNothing()) {
     return MaybeLocal<Object>();
+  }
   return handle_scope.Escape(exports);
 }
 
 // Any initialization logic should be performed in
 // InitializeContext, because embedders don't necessarily
 // call NewContext and so they will experience breakages.
 Local<Context> NewContext(Isolate* isolate,
+                          IsolateData* isolate_data,
                           Local<ObjectTemplate> object_template) {
   auto context = Context::New(isolate, nullptr, object_template);
   if (context.IsEmpty()) return context;
 
-  if (InitializeContext(context).IsNothing()) {
+  if (InitializeContext(context, isolate_data).IsNothing()) {
     return Local<Context>();
   }
 
@@ -745,7 +749,8 @@ Maybe<void> InitializeBaseContextForSnapshot(Local<Context> context) {
   return JustVoid();
 }
 
-Maybe<void> InitializeMainContextForSnapshot(Local<Context> context) {
+Maybe<void> InitializeMainContextForSnapshot(Local<Context> context,
+                                             IsolateData* isolate_data) {
   Isolate* isolate = context->GetIsolate();
   HandleScope handle_scope(isolate);
 
@@ -758,10 +763,35 @@ Maybe<void> InitializeMainContextForSnapshot(Local<Context> context) {
   if (InitializeBaseContextForSnapshot(context).IsNothing()) {
     return Nothing<void>();
   }
-  return InitializePrimordials(context);
+  return InitializePrimordials(context, isolate_data);
+}
+
+Local<Object> InitializePrivateSymbols(Local<Context> context,
+                                       IsolateData* isolate_data) {
+  Isolate* isolate = context->GetIsolate();
+  EscapableHandleScope scope(isolate);
+  Context::Scope context_scope(context);
+
+  Local<ObjectTemplate> private_symbols;
+  Local<Object> private_symbols_object;
+  private_symbols = ObjectTemplate::New(isolate);
+#define V(PropertyName, _)                                                     \
+  private_symbols->Set(isolate, #PropertyName, isolate_data->PropertyName());
+
+  PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(V)
+#undef V
+
+  if (!private_symbols->NewInstance(context).ToLocal(&private_symbols_object) ||
+      private_symbols_object->SetPrototypeV2(context, Null(isolate))
+          .IsNothing()) {
+    return Local<Object>();
+  }
+
+  return scope.Escape(private_symbols_object);
 }
 
-Maybe<void> InitializePrimordials(Local<Context> context) {
+Maybe<void> InitializePrimordials(Local<Context> context,
+                                  IsolateData* isolate_data) {
   // Run per-context JS files.
   Isolate* isolate = context->GetIsolate();
   Context::Scope context_scope(context);
@@ -772,12 +802,18 @@ Maybe<void> InitializePrimordials(Local<Context> context) {
 
   // Create primordials first and make it available to per-context scripts.
   Local<Object> primordials = Object::New(isolate);
+
   if (primordials->SetPrototypeV2(context, Null(isolate)).IsNothing() ||
-      !GetPerContextExports(context).ToLocal(&exports) ||
+      !GetPerContextExports(context, isolate_data).ToLocal(&exports) ||
       exports->Set(context, primordials_string, primordials).IsNothing()) {
     return Nothing<void>();
   }
 
+  Local<Object> private_symbols;
+  if (isolate_data != nullptr) {
+    private_symbols = InitializePrivateSymbols(context, isolate_data);
+  }
+
   static const char* context_files[] = {"internal/per_context/primordials",
                                         "internal/per_context/domexception",
                                         "internal/per_context/messageport",
@@ -793,7 +829,13 @@ Maybe<void> InitializePrimordials(Local<Context> context) {
   builtin_loader.SetEagerCompile();
 
   for (const char** module = context_files; *module != nullptr; module++) {
-    Local<Value> arguments[] = {exports, primordials};
+    Local<Value> arguments[3];
+    arguments[0] = exports;
+    arguments[1] = primordials;
+    arguments[2] = private_symbols.IsEmpty() ? 
+                   Local<Value>(Undefined(isolate)) : 
+                   Local<Value>(private_symbols);
+
     if (builtin_loader
             .CompileAndCall(
                 context, *module, arraysize(arguments), arguments, nullptr)
@@ -807,8 +849,9 @@ Maybe<void> InitializePrimordials(Local<Context> context) {
 }
 
 // This initializes the main context (i.e. vm contexts are not included).
-Maybe<bool> InitializeContext(Local<Context> context) {
-  if (InitializeMainContextForSnapshot(context).IsNothing()) {
+Maybe<bool> InitializeContext(Local<Context> context,
+                              IsolateData* isolate_data) {
+  if (InitializeMainContextForSnapshot(context, isolate_data).IsNothing()) {
     return Nothing<bool>();
   }
 

src/env_properties.h

@@ -23,6 +23,7 @@
   V(decorated_private_symbol, "node:decorated")                                \
   V(transfer_mode_private_symbol, "node:transfer_mode")                        \
   V(host_defined_option_symbol, "node:host_defined_option_symbol")             \
+  V(is_dom_exception, "node:is_dom_exception")                                 \
   V(js_transferable_wrapper_private_symbol, "node:js_transferable_wrapper")    \
   V(entry_point_module_private_symbol, "node:entry_point_module")              \
   V(entry_point_promise_private_symbol, "node:entry_point_promise")            \

src/node.h

@@ -590,12 +590,14 @@ NODE_EXTERN v8::Isolate* NewIsolate(
 // Creates a new context with Node.js-specific tweaks.
 NODE_EXTERN v8::Local<v8::Context> NewContext(
     v8::Isolate* isolate,
+    IsolateData* isolate_data = nullptr,
     v8::Local<v8::ObjectTemplate> object_template =
         v8::Local<v8::ObjectTemplate>());
 
 // Runs Node.js-specific tweaks on an already constructed context
 // Return value indicates success of operation
-NODE_EXTERN v8::Maybe<bool> InitializeContext(v8::Local<v8::Context> context);
+NODE_EXTERN v8::Maybe<bool> InitializeContext(
+    v8::Local<v8::Context> context, IsolateData* isolate_data = nullptr);
 
 // If `platform` is passed, it will be used to register new Worker instances.
 // It can be `nullptr`, in which case creating new Workers inside of

src/node_builtins.cc

@@ -402,6 +402,7 @@ MaybeLocal<Function> BuiltinLoader::LookupAndCompile(Local<Context> context,
     parameters = {
         FIXED_ONE_BYTE_STRING(isolate, "exports"),
         FIXED_ONE_BYTE_STRING(isolate, "primordials"),
+        FIXED_ONE_BYTE_STRING(isolate, "privateSymbols"),
     };
   } else if (strncmp(id, "internal/main/", strlen("internal/main/")) == 0 ||
              strncmp(id,

src/node_internals.h

@@ -113,7 +113,10 @@ std::string GetHumanReadableProcessName();
 v8::Maybe<void> InitializeBaseContextForSnapshot(
     v8::Local<v8::Context> context);
 v8::Maybe<void> InitializeContextRuntime(v8::Local<v8::Context> context);
-v8::Maybe<void> InitializePrimordials(v8::Local<v8::Context> context);
+v8::Maybe<void> InitializePrimordials(v8::Local<v8::Context> context,
+                                      IsolateData* isolate_data);
+v8::Local<v8::Object> InitializePrivateSymbols(v8::Local<v8::Context> context,
+                                               IsolateData* isolate_data);
 
 class NodeArrayBufferAllocator : public ArrayBufferAllocator {
  public:
@@ -340,7 +343,8 @@ v8::Isolate* NewIsolate(v8::Isolate::CreateParams* params,
 // was provided by the embedder.
 v8::MaybeLocal<v8::Value> StartExecution(Environment* env,
                                          StartExecutionCallback cb = nullptr);
-v8::MaybeLocal<v8::Object> GetPerContextExports(v8::Local<v8::Context> context);
+v8::MaybeLocal<v8::Object> GetPerContextExports(
+    v8::Local<v8::Context> context, IsolateData* isolate_data = nullptr);
 void MarkBootstrapComplete(const v8::FunctionCallbackInfo<v8::Value>& args);
 
 class InitializationResultImpl final : public InitializationResult {

src/node_main_instance.cc

@@ -140,7 +140,7 @@ NodeMainInstance::CreateMainEnvironment(ExitCode* exit_code) {
     crypto::InitCryptoOnce(isolate_);
 #endif  // HAVE_OPENSSL
   } else {
-    context = NewContext(isolate_);
+    context = NewContext(isolate_, isolate_data_.get());
     CHECK(!context.IsEmpty());
     Context::Scope context_scope(context);
     env.reset(