lib,src: implement QuotaExceededError as DOMException-derived interface

Implement QuotaExceededError as a DOMException-derived interface per the
WebIDL specification update.

QuotaExceededError is now a proper constructor exposed as a global
[Exposed=*] interface that extends DOMException with optional `quota`
and `requested` attributes (both nullable doubles, defaulting to null).

The constructor validates that quota and requested are finite,
non-negative, and that requested is not less than quota when both are
provided.

QuotaExceededError is [Serializable] and supports structuredClone,
preserving the quota and requested values across the serialization
boundary.

Callers updated:
- crypto.getRandomValues() now throws a QuotaExceededError instance
- WebStorage (C++) now constructs QuotaExceededError directly

Refs: https://redirect.github.com/whatwg/webidl/pull/1465
Fixes: #58987
PR-URL: #62293

Reviewed-By: Mattias Buelens <[email protected]>
Reviewed-By: Chengzhong Wu <[email protected]>
Reviewed-By: Michaël Zasso <[email protected]>
Reviewed-By: Colin Ihrig <[email protected]>

Author: panva

doc/api/globals.md

@@ -976,6 +976,14 @@ DataHandler.prototype.load = async function load(key) {
 };
 ```
 
+## Class: `QuotaExceededError`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+The WHATWG {QuotaExceededError} class. Extends {DOMException}.
+
 ## Class: `ReadableByteStreamController`
 
 <!-- YAML

eslint.config.mjs

@@ -130,6 +130,7 @@ export default [
         Float16Array: 'readonly',
         FormData: 'readonly',
         navigator: 'readonly',
+        QuotaExceededError: 'readonly',
         ReadableStream: 'readonly',
         ReadableStreamDefaultReader: 'readonly',
         ReadableStreamBYOBReader: 'readonly',

lib/eslint.config_partial.mjs

@@ -23,7 +23,7 @@ const noRestrictedSyntax = [
     message: "`btoa` supports only latin-1 charset, use Buffer.from(str).toString('base64') instead",
   },
   {
-    selector: 'NewExpression[callee.name=/Error$/]:not([callee.name=/^(AssertionError|NghttpError|AbortError|NodeAggregateError)$/])',
+    selector: 'NewExpression[callee.name=/Error$/]:not([callee.name=/^(AssertionError|NghttpError|AbortError|NodeAggregateError|QuotaExceededError)$/])',
     message: "Use an error exported by 'internal/errors' instead.",
   },
   {
@@ -122,6 +122,10 @@ export default [
           name: 'DOMException',
           message: "Use lazy function `const { lazyDOMExceptionClass } = require('internal/util');` instead of the global.",
         },
+        {
+          name: 'QuotaExceededError',
+          message: "Use `internalBinding('messaging').QuotaExceededError` instead of the global.",
+        },
         {
           name: 'ErrorEvent',
           message: "Use `const { ErrorEvent } = require('internal/deps/undici/undici');` instead of the global.",

lib/internal/bootstrap/web/exposed-wildcard.js

@@ -29,6 +29,11 @@ exposeInterface(globalThis, 'URL', URL);
 exposeInterface(globalThis, 'URLSearchParams', URLSearchParams);
 exposeLazyDOMExceptionProperty(globalThis);
 
+// https://webidl.spec.whatwg.org/#quotaexceedederror
+exposeLazyInterfaces(globalThis, 'internal/worker/clone_dom_exception', [
+  'QuotaExceededError',
+]);
+
 // https://dom.spec.whatwg.org/#interface-abortcontroller
 // Lazy ones.
 exposeLazyInterfaces(globalThis, 'internal/abort_controller', [

lib/internal/crypto/random.js

@@ -328,9 +328,9 @@ function getRandomValues(data) {
       'TypeMismatchError');
   }
   if (data.byteLength > 65536) {
-    throw lazyDOMException(
-      'The requested length exceeds 65,536 bytes',
-      'QuotaExceededError');
+    const { QuotaExceededError } = internalBinding('messaging');
+    throw new QuotaExceededError(
+      'The requested length exceeds 65,536 bytes');
   }
   randomFillSync(data, 0);
   return data;

lib/internal/per_context/domexception.js

@@ -3,9 +3,12 @@
 const {
   Error,
   ErrorPrototype,
+  NumberIsFinite,
+  NumberIsNaN,
   ObjectDefineProperties,
   ObjectDefineProperty,
   ObjectSetPrototypeOf,
+  RangeError,
   SafeMap,
   SafeSet,
   SafeWeakMap,
@@ -203,3 +206,91 @@ for (const { 0: name, 1: codeName, 2: value } of [
 }
 
 exports.DOMException = DOMException;
+
+// https://webidl.spec.whatwg.org/#quotaexceedederror
+class QuotaExceededError extends DOMException {
+  #quota;
+  #requested;
+
+  constructor(message = '', options = { __proto__: null }) {
+    super(message, 'QuotaExceededError');
+    this[transfer_mode_private_symbol] = kCloneable;
+
+    let quota = null;
+    let requested = null;
+
+    if (options !== null && options !== undefined) {
+      if ('quota' in options) {
+        quota = +options.quota;
+        if (!NumberIsFinite(quota)) {
+          // eslint-disable-next-line no-restricted-syntax
+          throw new TypeError(
+            `Cannot convert options.quota to a double: the value is ${NumberIsNaN(quota) ? 'NaN' : 'Infinity'}`,
+          );
+        }
+        if (quota < 0) {
+          // eslint-disable-next-line no-restricted-syntax
+          throw new RangeError('options.quota must not be negative');
+        }
+      }
+
+      if ('requested' in options) {
+        requested = +options.requested;
+        if (!NumberIsFinite(requested)) {
+          // eslint-disable-next-line no-restricted-syntax
+          throw new TypeError(
+            `Cannot convert options.requested to a double: the value is ${NumberIsNaN(requested) ? 'NaN' : 'Infinity'}`,
+          );
+        }
+        if (requested < 0) {
+          // eslint-disable-next-line no-restricted-syntax
+          throw new RangeError('options.requested must not be negative');
+        }
+      }
+    }
+
+    if (quota !== null && requested !== null && requested < quota) {
+      // eslint-disable-next-line no-restricted-syntax
+      throw new RangeError('options.requested must not be less than options.quota');
+    }
+
+    this.#quota = quota;
+    this.#requested = requested;
+  }
+
+  [messaging_clone_symbol]() {
+    const domExceptionClone = DOMExceptionPrototype[messaging_clone_symbol].call(this);
+    domExceptionClone.data.quota = this.#quota;
+    domExceptionClone.data.requested = this.#requested;
+    domExceptionClone.deserializeInfo = 'internal/worker/clone_dom_exception:QuotaExceededError';
+    return domExceptionClone;
+  }
+
+  [messaging_deserialize_symbol](data) {
+    DOMExceptionPrototype[messaging_deserialize_symbol].call(this, data);
+    this.#quota = data.quota;
+    this.#requested = data.requested;
+  }
+
+  get quota() {
+    if (!(#quota in this)) {
+      throwInvalidThisError(TypeError, 'QuotaExceededError');
+    }
+    return this.#quota;
+  }
+
+  get requested() {
+    if (!(#requested in this)) {
+      throwInvalidThisError(TypeError, 'QuotaExceededError');
+    }
+    return this.#requested;
+  }
+}
+
+ObjectDefineProperties(QuotaExceededError.prototype, {
+  [SymbolToStringTag]: { __proto__: null, configurable: true, value: 'QuotaExceededError' },
+  quota: { __proto__: null, enumerable: true, configurable: true },
+  requested: { __proto__: null, enumerable: true, configurable: true },
+});
+
+exports.QuotaExceededError = QuotaExceededError;

lib/internal/worker/clone_dom_exception.js

@@ -1,6 +1,8 @@
 'use strict';
 
-// Delegate to the actual DOMException implementation.
+// Delegate to the actual DOMException/QuotaExceededError implementation.
+const messaging = internalBinding('messaging');
 module.exports = {
-  DOMException: internalBinding('messaging').DOMException,
+  DOMException: messaging.DOMException,
+  QuotaExceededError: messaging.QuotaExceededError,
 };

src/node_messaging.cc

@@ -1762,6 +1762,21 @@ static void CreatePerContextProperties(Local<Object> target,
               domexception)
         .Check();
   }
+  {
+    Local<Object> per_context_bindings;
+    Local<Value> quota_exceeded_error_val;
+    if (GetPerContextExports(context).ToLocal(&per_context_bindings) &&
+        per_context_bindings
+            ->Get(context,
+                  FIXED_ONE_BYTE_STRING(env->isolate(), "QuotaExceededError"))
+            .ToLocal(&quota_exceeded_error_val)) {
+      target
+          ->Set(context,
+                FIXED_ONE_BYTE_STRING(env->isolate(), "QuotaExceededError"),
+                quota_exceeded_error_val)
+          .Check();
+    }
+  }
 }
 
 static void RegisterExternalReferences(ExternalReferenceRegistry* registry) {

src/node_webstorage.cc

@@ -57,23 +57,23 @@ using v8::Value;
 
 static void ThrowQuotaExceededException(Local<Context> context) {
   Isolate* isolate = Isolate::GetCurrent();
-  auto dom_exception_str = FIXED_ONE_BYTE_STRING(isolate, "DOMException");
-  auto err_name = FIXED_ONE_BYTE_STRING(isolate, "QuotaExceededError");
+  auto quota_exceeded_str =
+      FIXED_ONE_BYTE_STRING(isolate, "QuotaExceededError");
   auto err_message =
       FIXED_ONE_BYTE_STRING(isolate, "Setting the value exceeded the quota");
   Local<Object> per_context_bindings;
-  Local<Value> domexception_ctor_val;
+  Local<Value> quota_exceeded_ctor_val;
   if (!GetPerContextExports(context).ToLocal(&per_context_bindings) ||
-      !per_context_bindings->Get(context, dom_exception_str)
-           .ToLocal(&domexception_ctor_val)) {
+      !per_context_bindings->Get(context, quota_exceeded_str)
+           .ToLocal(&quota_exceeded_ctor_val)) {
     return;
   }
-  CHECK(domexception_ctor_val->IsFunction());
-  Local<Function> domexception_ctor = domexception_ctor_val.As<Function>();
-  Local<Value> argv[] = {err_message, err_name};
+  CHECK(quota_exceeded_ctor_val->IsFunction());
+  Local<Function> quota_exceeded_ctor = quota_exceeded_ctor_val.As<Function>();
+  Local<Value> argv[] = {err_message};
   Local<Value> exception;
 
-  if (!domexception_ctor->NewInstance(context, arraysize(argv), argv)
+  if (!quota_exceeded_ctor->NewInstance(context, arraysize(argv), argv)
            .ToLocal(&exception)) {
     return;
   }

test/common/globals.js

@@ -79,6 +79,7 @@ intrinsics.add('console');
 
 const webIdlExposedWildcard = new Set([
   'DOMException',
+  'QuotaExceededError',
   'TextEncoder',
   'TextDecoder',
   'AbortController',