src,lib: make DOMException available in all Contexts

This allows using `DOMException` from Node.js code for any
`vm.Context`.

PR-URL: #26497
Reviewed-By: James M Snell <jasnell@gmail.com>

lib/internal/bootstrap/cache.js

@@ -25,6 +25,7 @@ const cannotBeRequired = [
  'internal/bootstrap/node',
 
  'internal/per_context/setup',
+ 'internal/per_context/domexception',
 ];
 
 // Skip modules that cannot be required when they are not

lib/internal/bootstrap/node.js

@@ -220,8 +220,6 @@ if (!config.noBrowserGlobals) {
  defineOperation(global, 'setImmediate', timers.setImmediate);
 }
 
-setupDOMException();
-
 Object.defineProperty(process, 'argv0', {
  enumerable: true,
  configurable: false,
@@ -450,13 +448,6 @@ function setupQueueMicrotask() {
  });
 }
 
-function setupDOMException() {
- // Registers the constructor with C++.
- const DOMException = NativeModule.require('internal/domexception');
- const { registerDOMException } = internalBinding('messaging');
- registerDOMException(DOMException);
-}
-
 function noop() {}
 
 // https://heycam.github.io/webidl/#es-namespaces

lib/internal/domexception.js → lib/internal/per_context/domexception.js

@@ -1,6 +1,12 @@
 'use strict';
 
-const { ERR_INVALID_THIS } = require('internal/errors').codes;
+class ERR_INVALID_THIS extends TypeError {
+ constructor(type) {
+ super('Value of "this" must be of ' + type);
+ }
+
+ get code() { return 'ERR_INVALID_THIS'; }
+}
 
 const internalsMap = new WeakMap();
 
@@ -83,4 +89,4 @@ for (const [name, codeName, value] of [
  nameToCodeMap.set(name, value);
 }
 
-module.exports = DOMException;
+exports.DOMException = DOMException;

node.gyp

@@ -33,6 +33,7 @@
  'lib/internal/bootstrap/node.js',
  'lib/internal/bootstrap/pre_execution.js',
  'lib/internal/per_context/setup.js',
+ 'lib/internal/per_context/domexception.js',
  'lib/async_hooks.js',
  'lib/assert.js',
  'lib/buffer.js',
@@ -117,7 +118,6 @@
  'lib/internal/dgram.js',
  'lib/internal/dns/promises.js',
  'lib/internal/dns/utils.js',
- 'lib/internal/domexception.js',
  'lib/internal/encoding.js',
  'lib/internal/errors.js',
  'lib/internal/error-serdes.js',

src/api/environment.cc

@@ -15,14 +15,17 @@
 
 namespace node {
 using v8::Context;
+using v8::EscapableHandleScope;
 using v8::Function;
 using v8::HandleScope;
 using v8::Isolate;
 using v8::Local;
 using v8::MaybeLocal;
 using v8::Message;
 using v8::MicrotasksPolicy;
+using v8::Object;
 using v8::ObjectTemplate;
+using v8::Private;
 using v8::String;
 using v8::Value;
 
@@ -249,6 +252,26 @@ void FreePlatform(MultiIsolatePlatform* platform) {
  delete platform;
 }
 
+MaybeLocal<Object> GetPerContextExports(Local<Context> context) {
+ Isolate* isolate = context->GetIsolate();
+ EscapableHandleScope handle_scope(isolate);
+
+ Local<Object> global = context->Global();
+ Local<Private> key = Private::ForApi(isolate,
+ FIXED_ONE_BYTE_STRING(isolate, "node:per_context_binding_exports"));
+
+ Local<Value> existing_value;
+ if (!global->GetPrivate(context, key).ToLocal(&existing_value))
+ return MaybeLocal<Object>();
+ if (existing_value->IsObject())
+ return handle_scope.Escape(existing_value.As<Object>());
+
+ Local<Object> exports = Object::New(isolate);
+ if (context->Global()->SetPrivate(context, key, exports).IsNothing())
+ return MaybeLocal<Object>();
+ return handle_scope.Escape(exports);
+}
+
 Local<Context> NewContext(Isolate* isolate,
  Local<ObjectTemplate> object_template) {
  auto context = Context::New(isolate, nullptr, object_template);
@@ -261,16 +284,25 @@ Local<Context> NewContext(Isolate* isolate,
  {
  // Run per-context JS files.
  Context::Scope context_scope(context);
+ Local<Object> exports;
+ if (!GetPerContextExports(context).ToLocal(&exports))
+ return Local<Context>();
+
+ Local<String> global_string = FIXED_ONE_BYTE_STRING(isolate, "global");
+ Local<String> exports_string = FIXED_ONE_BYTE_STRING(isolate, "exports");
 
  static const char* context_files[] = {
  "internal/per_context/setup",
+ "internal/per_context/domexception",
  nullptr
  };
 
  for (const char** module = context_files; *module != nullptr; module++) {
  std::vector<Local<String>> parameters = {
- FIXED_ONE_BYTE_STRING(isolate, "global")};
- Local<Value> arguments[] = {context->Global()};
+ global_string,
+ exports_string
+ };
+ Local<Value> arguments[] = {context->Global(), exports};
  MaybeLocal<Function> maybe_fn =
  per_process::native_module_loader.LookupAndCompile(
  context, *module, &parameters, nullptr);

src/node_internals.h

@@ -294,6 +294,8 @@ void DefineZlibConstants(v8::Local<v8::Object> target);
 v8::MaybeLocal<v8::Value> RunBootstrapping(Environment* env);
 v8::MaybeLocal<v8::Value> StartExecution(Environment* env,
  const char* main_script_id);
+v8::MaybeLocal<v8::Object> GetPerContextExports(v8::Local<v8::Context> context);
+
 namespace coverage {
 bool StartCoverageCollection(Environment* env);
 }

src/node_messaging.cc

@@ -177,19 +177,30 @@ uint32_t Message::AddWASMModule(WasmCompiledModule::TransferrableModule&& mod) {
 
 namespace {
 
-void ThrowDataCloneException(Environment* env, Local<String> message) {
+void ThrowDataCloneException(Local<Context> context, Local<String> message) {
+ Isolate* isolate = context->GetIsolate();
  Local<Value> argv[] = {
  message,
- FIXED_ONE_BYTE_STRING(env->isolate(), "DataCloneError")
+ FIXED_ONE_BYTE_STRING(isolate, "DataCloneError")
  };
  Local<Value> exception;
- Local<Function> domexception_ctor = env->domexception_function();
- CHECK(!domexception_ctor.IsEmpty());
- if (!domexception_ctor->NewInstance(env->context(), arraysize(argv), argv)
+
+ Local<Object> per_context_bindings;
+ Local<Value> domexception_ctor_val;
+ if (!GetPerContextExports(context).ToLocal(&per_context_bindings) ||
+ !per_context_bindings->Get(context,
+ FIXED_ONE_BYTE_STRING(isolate, "DOMException"))
+ .ToLocal(&domexception_ctor_val)) {
+ return;
+ }
+
+ CHECK(domexception_ctor_val->IsFunction());
+ Local<Function> domexception_ctor = domexception_ctor_val.As<Function>();
+ if (!domexception_ctor->NewInstance(context, arraysize(argv), argv)
  .ToLocal(&exception)) {
  return;
  }
- env->isolate()->ThrowException(exception);
+ isolate->ThrowException(exception);
 }
 
 // This tells V8 how to serialize objects that it does not understand
@@ -201,7 +212,7 @@ class SerializerDelegate : public ValueSerializer::Delegate {
  : env_(env), context_(context), msg_(m) {}
 
  void ThrowDataCloneError(Local<String> message) override {
- ThrowDataCloneException(env_, message);
+ ThrowDataCloneException(context_, message);
  }
 
  Maybe<bool> WriteHostObject(Isolate* isolate, Local<Object> object) override {
@@ -309,7 +320,7 @@ Maybe<bool> Message::Serialize(Environment* env,
  if (std::find(array_buffers.begin(), array_buffers.end(), ab) !=
  array_buffers.end()) {
  ThrowDataCloneException(
- env,
+ context,
  FIXED_ONE_BYTE_STRING(
  env->isolate(),
  "Transfer list contains duplicate ArrayBuffer"));
@@ -326,15 +337,15 @@ Maybe<bool> Message::Serialize(Environment* env,
  // Check if the source MessagePort is being transferred.
  if (!source_port.IsEmpty() && entry == source_port) {
  ThrowDataCloneException(
- env,
+ context,
  FIXED_ONE_BYTE_STRING(env->isolate(),
  "Transfer list contains source port"));
  return Nothing<bool>();
  }
  MessagePort* port = Unwrap<MessagePort>(entry.As<Object>());
  if (port == nullptr || port->IsDetached()) {
  ThrowDataCloneException(
- env,
+ context,
  FIXED_ONE_BYTE_STRING(
  env->isolate(),
  "MessagePort in transfer list is already detached"));
@@ -343,7 +354,7 @@ Maybe<bool> Message::Serialize(Environment* env,
  if (std::find(delegate.ports_.begin(), delegate.ports_.end(), port) !=
  delegate.ports_.end()) {
  ThrowDataCloneException(
- env,
+ context,
  FIXED_ONE_BYTE_STRING(
  env->isolate(),
  "Transfer list contains duplicate MessagePort"));
@@ -811,13 +822,6 @@ static void MessageChannel(const FunctionCallbackInfo<Value>& args) {
  .FromJust();
 }
 
-static void RegisterDOMException(const FunctionCallbackInfo<Value>& args) {
- Environment* env = Environment::GetCurrent(args);
- CHECK_EQ(args.Length(), 1);
- CHECK(args[0]->IsFunction());
- env->set_domexception_function(args[0].As<Function>());
-}
-
 static void InitMessaging(Local<Object> target,
  Local<Value> unused,
  Local<Context> context,
@@ -839,8 +843,6 @@ static void InitMessaging(Local<Object> target,
  GetMessagePortConstructor(env, context).ToLocalChecked())
  .FromJust();
 
- env->SetMethod(target, "registerDOMException", RegisterDOMException);
-
  // These are not methods on the MessagePort prototype, because
  // the browser equivalents do not provide them.
  env->SetMethod(target, "stopMessagePort", MessagePort::Stop);

test/parallel/test-bootstrap-modules.js

@@ -17,7 +17,6 @@ const expectedModules = new Set([
  'Internal Binding credentials',
  'Internal Binding fs',
  'Internal Binding inspector',
- 'Internal Binding messaging',
  'Internal Binding module_wrap',
  'Internal Binding native_module',
  'Internal Binding options',
@@ -38,7 +37,6 @@ const expectedModules = new Set([
  'NativeModule internal/console/constructor',
  'NativeModule internal/console/global',
  'NativeModule internal/constants',
- 'NativeModule internal/domexception',
  'NativeModule internal/encoding',
  'NativeModule internal/errors',
  'NativeModule internal/fixed_queue',
@@ -74,6 +72,7 @@ if (common.isMainThread) {
  expectedModules.add('NativeModule internal/process/stdio');
 } else {
  expectedModules.add('Internal Binding heap_utils');
+ expectedModules.add('Internal Binding messaging');
  expectedModules.add('Internal Binding serdes');
  expectedModules.add('Internal Binding stream_wrap');
  expectedModules.add('Internal Binding symbols');

test/wpt/test-url.js

@@ -3,16 +3,30 @@
 // Flags: --expose-internals
 
 require('../common');
+const assert = require('assert');
 const { WPTRunner } = require('../common/wpt');
 
 const runner = new WPTRunner('url');
 
 // Copy global descriptors from the global object
 runner.copyGlobalsFromObject(global, ['URL', 'URLSearchParams']);
 // Needed by urlsearchparams-constructor.any.js
+let DOMException;
 runner.defineGlobal('DOMException', {
  get() {
- return require('internal/domexception');
+ // A 'hack' to get the DOMException constructor since we don't have it
+ // on the global object.
+ if (DOMException === undefined) {
+ const port = new (require('worker_threads').MessagePort)();
+ const ab = new ArrayBuffer(1);
+ try {
+ port.postMessage(ab, [ab, ab]);
+ } catch (err) {
+ DOMException = err.constructor;
+ }
+ assert.strictEqual(DOMException.name, 'DOMException');
+ }
+ return DOMException;
  }
 });