From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Fri, 19 Apr 2024 02:47:55 +0200
Subject: Adding upstream version 124.0.1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 dom/webgpu/mochitest/mochitest-no-pref.toml        |  10 +
 dom/webgpu/mochitest/mochitest.toml                | 116 +++++++++
 dom/webgpu/mochitest/test_basic_canvas.worker.html |  18 ++
 dom/webgpu/mochitest/test_basic_canvas.worker.js   |  32 +++
 dom/webgpu/mochitest/test_buffer_mapping.html      |  73 ++++++
 .../test_buffer_mapping_invalid_device.html        |  60 +++++
 .../mochitest/test_command_buffer_creation.html    |  29 +++
 dom/webgpu/mochitest/test_context_configure.html   |  48 ++++
 dom/webgpu/mochitest/test_device_creation.html     |  29 +++
 dom/webgpu/mochitest/test_device_lost.html         |  73 ++++++
 dom/webgpu/mochitest/test_disabled.html            |  17 ++
 .../mochitest/test_double_encoder_finish.html      |  36 +++
 dom/webgpu/mochitest/test_enabled.html             |  17 ++
 dom/webgpu/mochitest/test_error_scope.html         |  43 ++++
 dom/webgpu/mochitest/test_insecure_context.html    |  22 ++
 .../test_navigator_gpu_not_replaceable.html        |  32 +++
 .../test_queue_copyExternalImageToTexture.html     | 261 +++++++++++++++++++++
 dom/webgpu/mochitest/test_queue_write.html         |  50 ++++
 .../mochitest/test_queue_write_invalid_device.html |  44 ++++
 .../mochitest/test_submit_compute_empty.html       |  32 +++
 dom/webgpu/mochitest/test_submit_render_empty.html |  57 +++++
 .../mochitest/test_submit_render_empty.worker.html |  14 ++
 .../mochitest/test_submit_render_empty.worker.js   |  49 ++++
 dom/webgpu/mochitest/worker_wrapper.js             |  33 +++
 24 files changed, 1195 insertions(+)
 create mode 100644 dom/webgpu/mochitest/mochitest-no-pref.toml
 create mode 100644 dom/webgpu/mochitest/mochitest.toml
 create mode 100644 dom/webgpu/mochitest/test_basic_canvas.worker.html
 create mode 100644 dom/webgpu/mochitest/test_basic_canvas.worker.js
 create mode 100644 dom/webgpu/mochitest/test_buffer_mapping.html
 create mode 100644 dom/webgpu/mochitest/test_buffer_mapping_invalid_device.html
 create mode 100644 dom/webgpu/mochitest/test_command_buffer_creation.html
 create mode 100644 dom/webgpu/mochitest/test_context_configure.html
 create mode 100644 dom/webgpu/mochitest/test_device_creation.html
 create mode 100644 dom/webgpu/mochitest/test_device_lost.html
 create mode 100644 dom/webgpu/mochitest/test_disabled.html
 create mode 100644 dom/webgpu/mochitest/test_double_encoder_finish.html
 create mode 100644 dom/webgpu/mochitest/test_enabled.html
 create mode 100644 dom/webgpu/mochitest/test_error_scope.html
 create mode 100644 dom/webgpu/mochitest/test_insecure_context.html
 create mode 100644 dom/webgpu/mochitest/test_navigator_gpu_not_replaceable.html
 create mode 100644 dom/webgpu/mochitest/test_queue_copyExternalImageToTexture.html
 create mode 100644 dom/webgpu/mochitest/test_queue_write.html
 create mode 100644 dom/webgpu/mochitest/test_queue_write_invalid_device.html
 create mode 100644 dom/webgpu/mochitest/test_submit_compute_empty.html
 create mode 100644 dom/webgpu/mochitest/test_submit_render_empty.html
 create mode 100644 dom/webgpu/mochitest/test_submit_render_empty.worker.html
 create mode 100644 dom/webgpu/mochitest/test_submit_render_empty.worker.js
 create mode 100644 dom/webgpu/mochitest/worker_wrapper.js

(limited to 'dom/webgpu/mochitest')

diff --git a/dom/webgpu/mochitest/mochitest-no-pref.toml b/dom/webgpu/mochitest/mochitest-no-pref.toml
new file mode 100644
index 0000000000..511b840c0b
--- /dev/null
+++ b/dom/webgpu/mochitest/mochitest-no-pref.toml
@@ -0,0 +1,10 @@
+[DEFAULT]
+subsuite = "webgpu"
+run-if = ["release_or_beta"]
+
+# Even if the pref were enabled, WebGPU is only available in secure contexts.
+#
+# See spec WebIDL, like this: https://www.w3.org/TR/webgpu/#navigatorgpu
+scheme = "https"
+
+["test_disabled.html"]
diff --git a/dom/webgpu/mochitest/mochitest.toml b/dom/webgpu/mochitest/mochitest.toml
new file mode 100644
index 0000000000..f32d7a9a86
--- /dev/null
+++ b/dom/webgpu/mochitest/mochitest.toml
@@ -0,0 +1,116 @@
+[DEFAULT]
+subsuite = "webgpu"
+run-if = ["!release_or_beta"]
+prefs = [
+  "dom.webgpu.enabled=true",
+  "dom.webgpu.workers.enabled=true",
+  "gfx.offscreencanvas.enabled=true",
+]
+support-files = [
+  "worker_wrapper.js",
+  "test_basic_canvas.worker.js",
+  "test_submit_render_empty.worker.js",
+]
+
+# WebGPU is only available in secure contexts.
+#
+# See spec WebIDL, like this: https://www.w3.org/TR/webgpu/#navigatorgpu
+scheme = "https"
+
+["test_basic_canvas.worker.html"]
+fail-if = [
+  "os == 'linux' && os_version == '18.04'",
+  "os == 'mac'",
+]
+
+["test_buffer_mapping.html"]
+fail-if = [
+  "os == 'linux' && os_version == '18.04'",
+  "os == 'mac'",
+]
+
+["test_buffer_mapping_invalid_device.html"]
+fail-if = [
+  "os == 'linux' && os_version == '18.04'",
+  "os == 'mac'",
+]
+
+["test_command_buffer_creation.html"]
+fail-if = [
+  "os == 'linux' && os_version == '18.04'",
+  "os == 'mac'",
+]
+
+["test_context_configure.html"]
+fail-if = [
+  "os == 'linux' && os_version == '18.04'",
+  "os == 'mac'",
+]
+
+["test_device_creation.html"]
+fail-if = [
+  "os == 'linux' && os_version == '18.04'",
+  "os == 'mac'",
+]
+
+["test_device_lost.html"]
+fail-if = [
+  "os == 'linux' && os_version == '18.04'",
+  "os == 'mac'",
+]
+
+["test_double_encoder_finish.html"]
+fail-if = [
+  "os == 'linux' && os_version == '18.04'",
+  "os == 'mac'",
+]
+
+["test_enabled.html"]
+
+["test_error_scope.html"]
+fail-if = [
+  "os == 'linux' && os_version == '18.04'",
+  "os == 'mac'",
+]
+
+["test_insecure_context.html"]
+# This test checks that WebGPU is not available in insecure contexts.
+scheme = "http"
+
+["test_navigator_gpu_not_replaceable.html"]
+
+["test_queue_copyExternalImageToTexture.html"]
+fail-if = [
+  "os == 'linux' && os_version == '18.04'",
+  "os == 'mac'",
+]
+
+["test_queue_write.html"]
+fail-if = [
+  "os == 'linux' && os_version == '18.04'",
+  "os == 'mac'",
+]
+
+["test_queue_write_invalid_device.html"]
+fail-if = [
+  "os == 'linux' && os_version == '18.04'",
+  "os == 'mac'",
+]
+
+["test_submit_compute_empty.html"]
+fail-if = [
+  "os == 'linux' && os_version == '18.04'",
+  "os == 'mac'",
+]
+
+["test_submit_render_empty.html"]
+fail-if = [
+  "os == 'linux' && os_version == '18.04'",
+  "os == 'mac'",
+]
+
+["test_submit_render_empty.worker.html"]
+fail-if = [
+  "os == 'linux' && os_version == '18.04'",
+  "os == 'mac'",
+]
diff --git a/dom/webgpu/mochitest/test_basic_canvas.worker.html b/dom/webgpu/mochitest/test_basic_canvas.worker.html
new file mode 100644
index 0000000000..a23ee9fc70
--- /dev/null
+++ b/dom/webgpu/mochitest/test_basic_canvas.worker.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+    <script src="worker_wrapper.js"></script>
+    <link rel="stylesheet" href="/tests/SimpleTest/test.css" />
+  </head>
+  <body>
+    <canvas id="canvas"></canvas>
+    <script>
+      const canvas = document.getElementById("canvas");
+      const offscreen = canvas.transferControlToOffscreen();
+
+      runWorkerTest("test_basic_canvas.worker.js", { offscreen }, [offscreen]);
+    </script>
+  </body>
+</html>
diff --git a/dom/webgpu/mochitest/test_basic_canvas.worker.js b/dom/webgpu/mochitest/test_basic_canvas.worker.js
new file mode 100644
index 0000000000..cec6d6f210
--- /dev/null
+++ b/dom/webgpu/mochitest/test_basic_canvas.worker.js
@@ -0,0 +1,32 @@
+self.addEventListener("message", async function (event) {
+  try {
+    const offscreen = event.data.offscreen;
+    const context = offscreen.getContext("webgpu");
+
+    const swapChainFormat = navigator.gpu.getPreferredCanvasFormat();
+    const adapter = await navigator.gpu.requestAdapter();
+    const device = await adapter.requestDevice();
+
+    context.configure({
+      device,
+      format: swapChainFormat,
+      size: { width: 100, height: 100, depth: 1 },
+    });
+
+    const texture = context.getCurrentTexture();
+
+    self.postMessage([
+      {
+        value: texture !== undefined,
+        message: "texture !== undefined",
+      },
+    ]);
+  } catch (e) {
+    self.postMessage([
+      {
+        value: false,
+        message: "Unhandled exception " + e,
+      },
+    ]);
+  }
+});
diff --git a/dom/webgpu/mochitest/test_buffer_mapping.html b/dom/webgpu/mochitest/test_buffer_mapping.html
new file mode 100644
index 0000000000..01dfbf893e
--- /dev/null
+++ b/dom/webgpu/mochitest/test_buffer_mapping.html
@@ -0,0 +1,73 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+    <link rel="stylesheet" href="/tests/SimpleTest/test.css" />
+  </head>
+  <body>
+    <script>
+      ok(
+        SpecialPowers.getBoolPref("dom.webgpu.enabled"),
+        "Pref should be enabled."
+      );
+
+      async function testBody() {
+        const adapter = await navigator.gpu.requestAdapter();
+        const device = await adapter.requestDevice();
+
+        const bufferRead = device.createBuffer({
+          size: 4,
+          usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
+        });
+        const bufferWrite = device.createBuffer({
+          size: 4,
+          usage: GPUBufferUsage.COPY_SRC,
+          mappedAtCreation: true,
+        });
+        new Float32Array(bufferWrite.getMappedRange()).set([1.0]);
+        bufferWrite.unmap();
+
+        const encoder = device.createCommandEncoder();
+        encoder.copyBufferToBuffer(bufferWrite, 0, bufferRead, 0, 4);
+        device.queue.submit([encoder.finish()]);
+
+        await bufferRead.mapAsync(GPUMapMode.READ);
+
+        try {
+          bufferRead.getMappedRange(0, 5);
+          ok(false, "mapped with size outside buffer should throw");
+        } catch (e) {
+          ok(
+            true,
+            "mapped with size outside buffer should throw OperationError"
+          );
+        }
+
+        try {
+          bufferRead.getMappedRange(4, 1);
+          ok(false, "mapped with offset outside buffer should throw");
+        } catch (e) {
+          ok(
+            true,
+            "mapped with offset outside buffer should throw OperationError"
+          );
+        }
+
+        const data = bufferRead.getMappedRange();
+        is(data.byteLength, 4, "array should be 4 bytes long");
+
+        const value = new Float32Array(data)[0];
+        ok(value == 1.0, "value == 1.0");
+
+        bufferRead.unmap();
+        is(data.byteLength, 0, "array should be detached after explicit unmap");
+      }
+
+      SimpleTest.waitForExplicitFinish();
+      testBody()
+        .catch(e => ok(false, "Unhandled exception " + e))
+        .finally(() => SimpleTest.finish());
+    </script>
+  </body>
+</html>
diff --git a/dom/webgpu/mochitest/test_buffer_mapping_invalid_device.html b/dom/webgpu/mochitest/test_buffer_mapping_invalid_device.html
new file mode 100644
index 0000000000..6b7e7fafad
--- /dev/null
+++ b/dom/webgpu/mochitest/test_buffer_mapping_invalid_device.html
@@ -0,0 +1,60 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+    <link rel="stylesheet" href="/tests/SimpleTest/test.css" />
+  </head>
+  <body>
+    <script>
+      ok(
+        SpecialPowers.getBoolPref("dom.webgpu.enabled"),
+        "Pref should be enabled."
+      );
+
+      async function testBody() {
+        const adapter = await navigator.gpu.requestAdapter({});
+        const device = await adapter.requestDevice({});
+        const bindGroupLayout = device.createBindGroupLayout({
+          entries: [
+            {
+              binding: 256,
+              storageTexture: { format: "bc1-rgba-unorm-srgb" },
+              visibility: GPUShaderStage.FRAGMENT,
+            },
+          ],
+        });
+        const buffer1 = device.createBuffer({
+          size: 32,
+          usage: GPUBufferUsage.MAP_READ,
+        });
+
+        // Call device.destroy, which makes the device invalid. Further object creation
+        // on device will create objects that are also invalid.
+        device.destroy();
+
+        // Create an invalid buffer2.
+        const buffer2 = device.createBuffer({
+          size: 32,
+          usage: GPUBufferUsage.MAP_WRITE,
+        });
+
+        // Create an invalid bind group, referencing invalid buffer2.
+        const bindGroup = device.createBindGroup({
+          layout: bindGroupLayout,
+          entries: [
+            { binding: 1, resource: { buffer: buffer1 } },
+            { binding: 2, resource: { buffer: buffer2 } },
+          ],
+        });
+
+        ok(bindGroup, "Created a bind group referencing an invalid buffer.");
+      }
+
+      SimpleTest.waitForExplicitFinish();
+      testBody()
+        .catch(e => ok(false, "Unhandled exception " + e))
+        .finally(() => SimpleTest.finish());
+    </script>
+  </body>
+</html>
diff --git a/dom/webgpu/mochitest/test_command_buffer_creation.html b/dom/webgpu/mochitest/test_command_buffer_creation.html
new file mode 100644
index 0000000000..a92c038afd
--- /dev/null
+++ b/dom/webgpu/mochitest/test_command_buffer_creation.html
@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+    <link rel="stylesheet" href="/tests/SimpleTest/test.css" />
+  </head>
+  <body>
+    <script>
+      ok(
+        SpecialPowers.getBoolPref("dom.webgpu.enabled"),
+        "Pref should be enabled."
+      );
+
+      const func = async function () {
+        const adapter = await navigator.gpu.requestAdapter();
+        const device = await adapter.requestDevice();
+        const encoder = device.createCommandEncoder();
+        const command_buffer = encoder.finish();
+        ok(command_buffer !== undefined, "command_buffer !== undefined");
+      };
+
+      SimpleTest.waitForExplicitFinish();
+      func()
+        .catch(e => ok(false, "Unhandled exception " + e))
+        .finally(() => SimpleTest.finish());
+    </script>
+  </body>
+</html>
diff --git a/dom/webgpu/mochitest/test_context_configure.html b/dom/webgpu/mochitest/test_context_configure.html
new file mode 100644
index 0000000000..7ca96d0afe
--- /dev/null
+++ b/dom/webgpu/mochitest/test_context_configure.html
@@ -0,0 +1,48 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+    <link rel="stylesheet" href="/tests/SimpleTest/test.css" />
+  </head>
+  <body>
+    <script>
+      ok(
+        SpecialPowers.getBoolPref("dom.webgpu.enabled"),
+        "Pref should be enabled."
+      );
+
+      async function testBody() {
+        const adapter = await navigator.gpu.requestAdapter({});
+        const device = await adapter.requestDevice({});
+        const canvas = document.createElement("canvas");
+        const context = canvas.getContext("webgpu");
+        const format = navigator.gpu.getPreferredCanvasFormat(adapter);
+
+        // Attempt to configure with a too-large canvas, which should
+        // fail due to device texture limits.
+        canvas.width = 1970696937;
+        let expectedError;
+        try {
+          context.configure({
+            device,
+            format,
+          });
+        } catch (error) {
+          expectedError = error;
+        }
+        // Bug 1864904: This should become an "is".
+        todo_is(
+          typeof expectedError,
+          "TypeError",
+          "Failed configure should generate a TypeError."
+        );
+      }
+
+      SimpleTest.waitForExplicitFinish();
+      testBody()
+        .catch(e => ok(false, "Unhandled exception " + e))
+        .finally(() => SimpleTest.finish());
+    </script>
+  </body>
+</html>
diff --git a/dom/webgpu/mochitest/test_device_creation.html b/dom/webgpu/mochitest/test_device_creation.html
new file mode 100644
index 0000000000..678359c323
--- /dev/null
+++ b/dom/webgpu/mochitest/test_device_creation.html
@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+    <link rel="stylesheet" href="/tests/SimpleTest/test.css" />
+  </head>
+  <body>
+    <script>
+      ok(
+        SpecialPowers.getBoolPref("dom.webgpu.enabled"),
+        "Pref should be enabled."
+      );
+
+      const func = async function () {
+        const adapter = await navigator.gpu.requestAdapter();
+        const limits = adapter.limits;
+        const features = adapter.features;
+        const device = await adapter.requestDevice();
+        ok(device !== undefined, "device !== undefined");
+      };
+
+      SimpleTest.waitForExplicitFinish();
+      func()
+        .catch(e => ok(false, "Unhandled exception " + e))
+        .finally(() => SimpleTest.finish());
+    </script>
+  </body>
+</html>
diff --git a/dom/webgpu/mochitest/test_device_lost.html b/dom/webgpu/mochitest/test_device_lost.html
new file mode 100644
index 0000000000..bc6614f0ef
--- /dev/null
+++ b/dom/webgpu/mochitest/test_device_lost.html
@@ -0,0 +1,73 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+    <link rel="stylesheet" href="/tests/SimpleTest/test.css" />
+  </head>
+  <body>
+    <script>
+      ok(
+        SpecialPowers.getBoolPref("dom.webgpu.enabled"),
+        "Pref should be enabled."
+      );
+
+      const destroy_causes_lost = async function () {
+        const adapter = await navigator.gpu.requestAdapter();
+        ok(adapter !== undefined, "adapter !== undefined");
+        const device = await adapter.requestDevice();
+        ok(device !== undefined, "device !== undefined");
+
+        const lostPromise = device.lost;
+        device.destroy();
+        const deviceLostReason = await lostPromise;
+
+        is(
+          deviceLostReason.reason,
+          "destroyed",
+          "Destroy reason should correspond to GPUDeviceLostReason.destroyed"
+        );
+        is(deviceLostReason.message, "", "Destroy message should be blank");
+      };
+
+      const drop_causes_lost_is_unobservable = async function () {
+        const adapter = await navigator.gpu.requestAdapter();
+        ok(adapter !== undefined, "adapter !== undefined");
+
+        let lostPromise;
+        // Create a scope with a device that will go out of scope
+        // and then be dropped.
+        {
+          const device = await adapter.requestDevice();
+          ok(device !== undefined, "device !== undefined");
+
+          lostPromise = device.lost;
+        }
+
+        SimpleTest.requestFlakyTimeout(
+          "Racing against promise that should never resolve."
+        );
+        const TIMEOUT_MS = 5000;
+        let timeoutPromise = new Promise(resolve => {
+          let timeoutValue = { reason: "timeout" };
+          // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+          setTimeout(() => resolve(timeoutValue), TIMEOUT_MS);
+        });
+
+        const firstPromise = await Promise.race([lostPromise, timeoutPromise]);
+        is(
+          firstPromise.reason,
+          "timeout",
+          "timeoutPromise should return before lostPromise."
+        );
+      };
+
+      SimpleTest.waitForExplicitFinish();
+
+      destroy_causes_lost()
+        .then(() => drop_causes_lost_is_unobservable())
+        .catch(e => ok(false, `Unhandled exception ${e}`))
+        .finally(() => SimpleTest.finish());
+    </script>
+  </body>
+</html>
diff --git a/dom/webgpu/mochitest/test_disabled.html b/dom/webgpu/mochitest/test_disabled.html
new file mode 100644
index 0000000000..12eb01e465
--- /dev/null
+++ b/dom/webgpu/mochitest/test_disabled.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+    <link rel="stylesheet" href="/tests/SimpleTest/test.css" />
+  </head>
+  <body>
+    <script>
+      ok(
+        !SpecialPowers.getBoolPref("dom.webgpu.enabled"),
+        "Pref should be disabled."
+      );
+      ok(navigator.gpu === undefined, "navigator.gpu === undefined");
+    </script>
+  </body>
+</html>
diff --git a/dom/webgpu/mochitest/test_double_encoder_finish.html b/dom/webgpu/mochitest/test_double_encoder_finish.html
new file mode 100644
index 0000000000..24c91c3165
--- /dev/null
+++ b/dom/webgpu/mochitest/test_double_encoder_finish.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+    <link rel="stylesheet" href="/tests/SimpleTest/test.css" />
+  </head>
+  <body>
+    <script>
+      ok(
+        SpecialPowers.getBoolPref("dom.webgpu.enabled"),
+        "Pref should be enabled."
+      );
+
+      const func = async function () {
+        const adapter = await navigator.gpu.requestAdapter();
+        const device = await adapter.requestDevice();
+        const encoder = device.createCommandEncoder();
+
+        const command_buffer = encoder.finish();
+        ok(command_buffer !== undefined, "command_buffer !== undefined");
+
+        const invalid_command_buffer = encoder.finish();
+        ok(
+          invalid_command_buffer !== undefined,
+          "invalid_command_buffer !== undefined"
+        );
+      };
+
+      SimpleTest.waitForExplicitFinish();
+      func()
+        .catch(e => ok(false, "Unhandled exception " + e))
+        .finally(() => SimpleTest.finish());
+    </script>
+  </body>
+</html>
diff --git a/dom/webgpu/mochitest/test_enabled.html b/dom/webgpu/mochitest/test_enabled.html
new file mode 100644
index 0000000000..318788bf1e
--- /dev/null
+++ b/dom/webgpu/mochitest/test_enabled.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+    <link rel="stylesheet" href="/tests/SimpleTest/test.css" />
+  </head>
+  <body>
+    <script>
+      ok(
+        SpecialPowers.getBoolPref("dom.webgpu.enabled"),
+        "Pref should be enabled."
+      );
+      ok(navigator.gpu !== undefined, "navigator.gpu !== undefined");
+    </script>
+  </body>
+</html>
diff --git a/dom/webgpu/mochitest/test_error_scope.html b/dom/webgpu/mochitest/test_error_scope.html
new file mode 100644
index 0000000000..f89b4b6e78
--- /dev/null
+++ b/dom/webgpu/mochitest/test_error_scope.html
@@ -0,0 +1,43 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+    <link rel="stylesheet" href="/tests/SimpleTest/test.css" />
+  </head>
+  <body>
+    <script>
+      ok(
+        SpecialPowers.getBoolPref("dom.webgpu.enabled"),
+        "Pref should be enabled."
+      );
+
+      const func = async function () {
+        const adapter = await navigator.gpu.requestAdapter();
+        const device = await adapter.requestDevice();
+
+        device.pushErrorScope("validation");
+        const buffer = device.createBuffer({ size: 0, usage: 0 });
+        const error = await device.popErrorScope();
+
+        isnot(
+          error,
+          null,
+          "Attempt to createBuffer with size 0 and usage 0 should generate an error."
+        );
+
+        try {
+          await device.popErrorScope();
+          ok(false, "Should have thrown");
+        } catch (ex) {
+          ok(ex.name == "OperationError", "Should throw an OperationError");
+        }
+      };
+
+      SimpleTest.waitForExplicitFinish();
+      func()
+        .catch(e => ok(false, "Unhandled exception " + e))
+        .finally(() => SimpleTest.finish());
+    </script>
+  </body>
+</html>
diff --git a/dom/webgpu/mochitest/test_insecure_context.html b/dom/webgpu/mochitest/test_insecure_context.html
new file mode 100644
index 0000000000..dcc4a313b9
--- /dev/null
+++ b/dom/webgpu/mochitest/test_insecure_context.html
@@ -0,0 +1,22 @@
+<!-- This is somewhat redundant with
+     dom/tests/mochitest/general/test_interfaces.js, but I think it's good to
+     have something here as well. -->
+
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+    <link rel="stylesheet" href="/tests/SimpleTest/test.css" />
+  </head>
+  <body>
+    <script>
+      ok(
+        SpecialPowers.getBoolPref("dom.webgpu.enabled"),
+        "Pref should be enabled."
+      );
+      ok(!isSecureContext, "test should not run in a secure context");
+      ok(navigator.gpu === undefined, "navigator.gpu === undefined");
+    </script>
+  </body>
+</html>
diff --git a/dom/webgpu/mochitest/test_navigator_gpu_not_replaceable.html b/dom/webgpu/mochitest/test_navigator_gpu_not_replaceable.html
new file mode 100644
index 0000000000..6b6b7b9715
--- /dev/null
+++ b/dom/webgpu/mochitest/test_navigator_gpu_not_replaceable.html
@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+    <link rel="stylesheet" href="/tests/SimpleTest/test.css" />
+  </head>
+  <body>
+    <script>
+      ok(
+        SpecialPowers.getBoolPref("dom.webgpu.enabled"),
+        "Pref should be enabled."
+      );
+      const originalNavigatorGpu = navigator.gpu;
+
+      const BAD_GPU_VAL = "ohcrapthisisbad";
+      ok(
+        navigator.gpu !== BAD_GPU_VAL,
+        "`navigator.gpu` should never equal `BAD_GPU_VAL` (before replacement attempt)"
+      );
+      navigator.gpu = BAD_GPU_VAL;
+      ok(
+        navigator.gpu !== BAD_GPU_VAL,
+        "`navigator.gpu` should never equal `BAD_GPU_VAL` (after replacement attempt)"
+      );
+      ok(
+        navigator.gpu === originalNavigatorGpu,
+        "`navigator.gpu` should equal originally observed value after attempted replacement"
+      );
+    </script>
+  </body>
+</html>
diff --git a/dom/webgpu/mochitest/test_queue_copyExternalImageToTexture.html b/dom/webgpu/mochitest/test_queue_copyExternalImageToTexture.html
new file mode 100644
index 0000000000..279b4a52b4
--- /dev/null
+++ b/dom/webgpu/mochitest/test_queue_copyExternalImageToTexture.html
@@ -0,0 +1,261 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+    <link rel="stylesheet" href="/tests/SimpleTest/test.css" />
+  </head>
+
+  <body>
+    <script type="text/javascript">
+      "use strict";
+
+      ok(
+        SpecialPowers.getBoolPref("dom.webgpu.enabled"),
+        "WebGPU pref should be enabled."
+      );
+      ok(
+        SpecialPowers.getBoolPref("gfx.offscreencanvas.enabled"),
+        "OffscreenCanvas pref should be enabled."
+      );
+
+      SimpleTest.waitForExplicitFinish();
+
+      function requestAnimationFramePromise() {
+        return new Promise(requestAnimationFrame);
+      }
+
+      function createSourceCanvasWebgl() {
+        const offscreenCanvas = new OffscreenCanvas(200, 200);
+        const gl = offscreenCanvas.getContext("webgl");
+
+        const COLOR_VALUE = 127.0 / 255.0;
+        const ALPHA_VALUE = 127.0 / 255.0;
+
+        gl.enable(gl.SCISSOR_TEST);
+
+        gl.scissor(0, 0, 100, 100);
+        gl.clearColor(COLOR_VALUE, 0.0, 0.0, ALPHA_VALUE);
+        gl.clear(gl.COLOR_BUFFER_BIT);
+
+        gl.scissor(100, 0, 100, 100);
+        gl.clearColor(0.0, COLOR_VALUE, 0.0, ALPHA_VALUE);
+        gl.clear(gl.COLOR_BUFFER_BIT);
+
+        gl.scissor(0, 100, 100, 100);
+        gl.clearColor(0.0, 0.0, COLOR_VALUE, ALPHA_VALUE);
+        gl.clear(gl.COLOR_BUFFER_BIT);
+
+        gl.scissor(100, 100, 100, 100);
+        gl.clearColor(0.0, 0.0, 0.0, ALPHA_VALUE);
+        gl.clear(gl.COLOR_BUFFER_BIT);
+
+        return {
+          source: offscreenCanvas,
+          origin: { x: 0, y: 0 },
+          flipY: true,
+        };
+      }
+
+      function createSourceCanvas2d() {
+        const offscreenCanvas = new OffscreenCanvas(200, 200);
+        const context = offscreenCanvas.getContext("2d");
+
+        context.fillStyle = "rgba(255,0,0,0.498)";
+        context.fillRect(0, 0, 100, 100);
+
+        context.fillStyle = "rgba(0,255,0,0.498)";
+        context.fillRect(100, 0, 100, 100);
+
+        context.fillStyle = "rgba(0,0,255,0.498)";
+        context.fillRect(0, 100, 100, 100);
+
+        context.fillStyle = "rgba(0,0,0,0.498)";
+        context.fillRect(100, 100, 100, 100);
+
+        return {
+          source: offscreenCanvas,
+          origin: { x: 0, y: 0 },
+          flipY: false,
+        };
+      }
+
+      function createSourceImageBitmap() {
+        const sourceCanvas = createSourceCanvas2d();
+        return {
+          source: sourceCanvas.source.transferToImageBitmap(),
+          origin: { x: 0, y: 0 },
+          flipY: false,
+        };
+      }
+
+      async function mapDestTexture(
+        device,
+        source,
+        destFormat,
+        premultiply,
+        copySize
+      ) {
+        const bytesPerRow = 256 * 4; // 256 aligned for 200 pixels
+        const texture = device.createTexture({
+          format: destFormat,
+          size: copySize,
+          usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST,
+        });
+
+        device.queue.copyExternalImageToTexture(
+          source,
+          { texture, premultipliedAlpha: premultiply },
+          copySize
+        );
+
+        const buffer = device.createBuffer({
+          size: 1024 * 200,
+          usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
+        });
+
+        const encoder = device.createCommandEncoder();
+        encoder.copyTextureToBuffer(
+          { texture },
+          { buffer, bytesPerRow },
+          copySize
+        );
+        device.queue.submit([encoder.finish()]);
+
+        await buffer.mapAsync(GPUMapMode.READ);
+        return buffer;
+      }
+
+      async function verifyBuffer(
+        test,
+        device,
+        source,
+        format,
+        premultiply,
+        copyDim,
+        topLeftPixelData
+      ) {
+        try {
+          const buffer = await mapDestTexture(
+            device,
+            source,
+            format,
+            premultiply,
+            copyDim
+          );
+          const arrayBuffer = buffer.getMappedRange();
+          const view = new Uint8Array(arrayBuffer);
+          for (let i = 0; i < topLeftPixelData.length; ++i) {
+            is(
+              view[i],
+              topLeftPixelData[i],
+              test +
+                " " +
+                format +
+                " (" +
+                source.origin.x +
+                "," +
+                source.origin.y +
+                ") channel " +
+                i
+            );
+          }
+        } catch (e) {
+          ok(false, "WebGPU exception: " + e);
+        }
+      }
+
+      async function verifySourceCanvas(test, device, source) {
+        await verifyBuffer(
+          test,
+          device,
+          source,
+          "rgba8unorm",
+          /* premultiply */ true,
+          { width: 200, height: 200 },
+          [127, 0, 0, 127]
+        );
+        await verifyBuffer(
+          test,
+          device,
+          source,
+          "bgra8unorm",
+          /* premultiply */ true,
+          { width: 200, height: 200 },
+          [0, 0, 127, 127]
+        );
+        await verifyBuffer(
+          test,
+          device,
+          source,
+          "rgba8unorm",
+          /* premultiply */ false,
+          { width: 200, height: 200 },
+          [255, 0, 0, 127]
+        );
+        await verifyBuffer(
+          test,
+          device,
+          source,
+          "bgra8unorm",
+          /* premultiply */ false,
+          { width: 200, height: 200 },
+          [0, 0, 255, 127]
+        );
+
+        // The copy is flipped but the origin is relative to the original source data,
+        // so we need to invert for WebGL.
+        const topRightPixelData =
+          test === "webgl" ? [0, 0, 0, 127] : [0, 127, 0, 127];
+        const topRightOrigin = { origin: { x: 100, y: 0 } };
+        await verifyBuffer(
+          test,
+          device,
+          { ...source, ...topRightOrigin },
+          "bgra8unorm",
+          /* premultiply */ true,
+          { width: 100, height: 100 },
+          topRightPixelData
+        );
+
+        const bottomLeftPixelData =
+          test === "webgl" ? [0, 0, 127, 127] : [127, 0, 0, 127];
+        const bottomLeftOrigin = { origin: { x: 0, y: 100 } };
+        await verifyBuffer(
+          test,
+          device,
+          { ...source, ...bottomLeftOrigin },
+          "bgra8unorm",
+          /* premultiply */ true,
+          { width: 100, height: 100 },
+          bottomLeftPixelData
+        );
+      }
+
+      async function writeDestCanvas(source2d, sourceWebgl, sourceImageBitmap) {
+        const adapter = await navigator.gpu.requestAdapter();
+        const device = await adapter.requestDevice();
+        await verifySourceCanvas("2d", device, source2d);
+        await verifySourceCanvas("imageBitmap", device, sourceImageBitmap);
+        await verifySourceCanvas("webgl", device, sourceWebgl);
+      }
+
+      async function runTest() {
+        try {
+          const source2d = createSourceCanvas2d();
+          const sourceWebgl = createSourceCanvasWebgl();
+          const sourceImageBitmap = createSourceImageBitmap();
+          await requestAnimationFramePromise();
+          await requestAnimationFramePromise();
+          await writeDestCanvas(source2d, sourceWebgl, sourceImageBitmap);
+        } catch (e) {
+          ok(false, "Uncaught exception: " + e);
+        } finally {
+          SimpleTest.finish();
+        }
+      }
+
+      runTest();
+    </script>
+  </body>
+</html>
diff --git a/dom/webgpu/mochitest/test_queue_write.html b/dom/webgpu/mochitest/test_queue_write.html
new file mode 100644
index 0000000000..585c1617cd
--- /dev/null
+++ b/dom/webgpu/mochitest/test_queue_write.html
@@ -0,0 +1,50 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+    <link rel="stylesheet" href="/tests/SimpleTest/test.css" />
+  </head>
+  <body>
+    <script>
+      ok(
+        SpecialPowers.getBoolPref("dom.webgpu.enabled"),
+        "Pref should be enabled."
+      );
+
+      const func = async function () {
+        const adapter = await navigator.gpu.requestAdapter();
+        const device = await adapter.requestDevice();
+        const buffer = device.createBuffer({
+          size: 16,
+          usage:
+            GPUBufferUsage.COPY_DST |
+            GPUBufferUsage.COPY_SRC |
+            GPUBufferUsage.VERTEX,
+        });
+        const arrayBuf = new ArrayBuffer(16);
+        new Int32Array(arrayBuf).fill(5);
+        device.queue.writeBuffer(buffer, 0, arrayBuf, 0);
+        const texture = device.createTexture({
+          size: [2, 2, 1],
+          dimension: "2d",
+          format: "rgba8unorm",
+          usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
+        });
+        device.queue.writeTexture(
+          { texture },
+          arrayBuf,
+          { bytesPerRow: 8 },
+          [2, 2, 1]
+        );
+        // this isn't a process check, we need to read back the contents and verify the writes happened
+        ok(device !== undefined, "");
+      };
+
+      SimpleTest.waitForExplicitFinish();
+      func()
+        .catch(e => ok(false, "Unhandled exception " + e))
+        .finally(() => SimpleTest.finish());
+    </script>
+  </body>
+</html>
diff --git a/dom/webgpu/mochitest/test_queue_write_invalid_device.html b/dom/webgpu/mochitest/test_queue_write_invalid_device.html
new file mode 100644
index 0000000000..09180dee7f
--- /dev/null
+++ b/dom/webgpu/mochitest/test_queue_write_invalid_device.html
@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+    <link rel="stylesheet" href="/tests/SimpleTest/test.css" />
+  </head>
+  <body>
+    <script>
+      ok(
+        SpecialPowers.getBoolPref("dom.webgpu.enabled"),
+        "Pref should be enabled."
+      );
+
+      const func = async function () {
+        const adapter = await navigator.gpu.requestAdapter();
+        const device = await adapter.requestDevice();
+
+        // Destroy the device, making it invalid.
+        device.destroy();
+
+        // Creating a buffer on an invalid device will create an invalid
+        // buffer.
+        const buffer = device.createBuffer({
+          size: 16,
+          usage:
+            GPUBufferUsage.COPY_DST |
+            GPUBufferUsage.COPY_SRC |
+            GPUBufferUsage.VERTEX,
+        });
+        const arrayBuf = new ArrayBuffer(16);
+        new Int32Array(arrayBuf).fill(5);
+
+        // Writing to an invalid buffer should not throw an error.
+        device.queue.writeBuffer(buffer, 0, arrayBuf, 0);
+      };
+
+      SimpleTest.waitForExplicitFinish();
+      func()
+        .catch(e => ok(false, "Unhandled exception " + e))
+        .finally(() => SimpleTest.finish());
+    </script>
+  </body>
+</html>
diff --git a/dom/webgpu/mochitest/test_submit_compute_empty.html b/dom/webgpu/mochitest/test_submit_compute_empty.html
new file mode 100644
index 0000000000..82cb9473c5
--- /dev/null
+++ b/dom/webgpu/mochitest/test_submit_compute_empty.html
@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+    <link rel="stylesheet" href="/tests/SimpleTest/test.css" />
+  </head>
+  <body>
+    <script>
+      ok(
+        SpecialPowers.getBoolPref("dom.webgpu.enabled"),
+        "Pref should be enabled."
+      );
+
+      const func = async function () {
+        const adapter = await navigator.gpu.requestAdapter();
+        const device = await adapter.requestDevice();
+        const encoder = device.createCommandEncoder();
+        const pass = encoder.beginComputePass();
+        pass.end();
+        const command_buffer = encoder.finish();
+        device.queue.submit([command_buffer]);
+        ok(command_buffer !== undefined, "command_buffer !== undefined");
+      };
+
+      SimpleTest.waitForExplicitFinish();
+      func()
+        .catch(e => ok(false, "Unhandled exception " + e))
+        .finally(() => SimpleTest.finish());
+    </script>
+  </body>
+</html>
diff --git a/dom/webgpu/mochitest/test_submit_render_empty.html b/dom/webgpu/mochitest/test_submit_render_empty.html
new file mode 100644
index 0000000000..bac0d1ede7
--- /dev/null
+++ b/dom/webgpu/mochitest/test_submit_render_empty.html
@@ -0,0 +1,57 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+    <link rel="stylesheet" href="/tests/SimpleTest/test.css" />
+  </head>
+  <body>
+    <script>
+      ok(
+        SpecialPowers.getBoolPref("dom.webgpu.enabled"),
+        "Pref should be enabled."
+      );
+
+      const func = async function () {
+        const adapter = await navigator.gpu.requestAdapter();
+        const device = await adapter.requestDevice();
+
+        const swapChainFormat = "rgba8unorm";
+        const bundleEncoder = device.createRenderBundleEncoder({
+          colorFormats: [swapChainFormat],
+        });
+        const bundle = bundleEncoder.finish({});
+
+        const texture = device.createTexture({
+          size: { width: 100, height: 100, depth: 1 },
+          format: swapChainFormat,
+          usage: GPUTextureUsage.RENDER_ATTACHMENT,
+        });
+        const view = texture.createView();
+
+        const encoder = device.createCommandEncoder();
+        const pass = encoder.beginRenderPass({
+          colorAttachments: [
+            {
+              view,
+              clearValue: { r: 0, g: 0, b: 0, a: 0 },
+              loadOp: "clear",
+              storeOp: "store",
+            },
+          ],
+        });
+        pass.executeBundles([bundle]);
+        pass.end();
+        const command_buffer = encoder.finish();
+
+        device.queue.submit([command_buffer]);
+        ok(command_buffer !== undefined, "command_buffer !== undefined");
+      };
+
+      SimpleTest.waitForExplicitFinish();
+      func()
+        .catch(e => ok(false, "Unhandled exception " + e))
+        .finally(() => SimpleTest.finish());
+    </script>
+  </body>
+</html>
diff --git a/dom/webgpu/mochitest/test_submit_render_empty.worker.html b/dom/webgpu/mochitest/test_submit_render_empty.worker.html
new file mode 100644
index 0000000000..8db3168be0
--- /dev/null
+++ b/dom/webgpu/mochitest/test_submit_render_empty.worker.html
@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+    <script src="worker_wrapper.js"></script>
+    <link rel="stylesheet" href="/tests/SimpleTest/test.css" />
+  </head>
+  <body>
+    <script>
+      runWorkerTest("test_submit_render_empty.worker.js", {}, []);
+    </script>
+  </body>
+</html>
diff --git a/dom/webgpu/mochitest/test_submit_render_empty.worker.js b/dom/webgpu/mochitest/test_submit_render_empty.worker.js
new file mode 100644
index 0000000000..334230c3c1
--- /dev/null
+++ b/dom/webgpu/mochitest/test_submit_render_empty.worker.js
@@ -0,0 +1,49 @@
+self.addEventListener("message", async function (event) {
+  try {
+    const adapter = await navigator.gpu.requestAdapter();
+    const device = await adapter.requestDevice();
+
+    const swapChainFormat = "rgba8unorm";
+    const bundleEncoder = device.createRenderBundleEncoder({
+      colorFormats: [swapChainFormat],
+    });
+    const bundle = bundleEncoder.finish({});
+
+    const texture = device.createTexture({
+      size: { width: 100, height: 100, depth: 1 },
+      format: swapChainFormat,
+      usage: GPUTextureUsage.RENDER_ATTACHMENT,
+    });
+    const view = texture.createView();
+
+    const encoder = device.createCommandEncoder();
+    const pass = encoder.beginRenderPass({
+      colorAttachments: [
+        {
+          view,
+          clearValue: { r: 0, g: 0, b: 0, a: 0 },
+          loadOp: "clear",
+          storeOp: "store",
+        },
+      ],
+    });
+    pass.executeBundles([bundle]);
+    pass.end();
+    const command_buffer = encoder.finish();
+
+    device.queue.submit([command_buffer]);
+    self.postMessage([
+      {
+        value: command_buffer !== undefined,
+        message: "command_buffer !== undefined",
+      },
+    ]);
+  } catch (e) {
+    self.postMessage([
+      {
+        value: false,
+        message: "Unhandled exception " + e,
+      },
+    ]);
+  }
+});
diff --git a/dom/webgpu/mochitest/worker_wrapper.js b/dom/webgpu/mochitest/worker_wrapper.js
new file mode 100644
index 0000000000..6f6de9002d
--- /dev/null
+++ b/dom/webgpu/mochitest/worker_wrapper.js
@@ -0,0 +1,33 @@
+ok(
+  SpecialPowers.getBoolPref("dom.webgpu.enabled"),
+  "WebGPU pref should be enabled."
+);
+ok(
+  SpecialPowers.getBoolPref("gfx.offscreencanvas.enabled"),
+  "OffscreenCanvas pref should be enabled."
+);
+SimpleTest.waitForExplicitFinish();
+
+const workerWrapperFunc = async function (worker_path, data, transfer) {
+  const worker = new Worker(worker_path);
+
+  const results = new Promise((resolve, reject) => {
+    worker.addEventListener("message", event => {
+      resolve(event.data);
+    });
+  });
+
+  worker.postMessage(data, transfer);
+  for (const result of await results) {
+    ok(result.value, result.message);
+  }
+};
+
+async function runWorkerTest(worker_path, data, transfer) {
+  try {
+    await workerWrapperFunc(worker_path, data, transfer);
+  } catch (e) {
+    ok(false, "Unhandled exception " + e);
+  }
+  SimpleTest.finish();
+}
-- 
cgit v1.2.3